关于面试技巧:笑傲Java面试面霸修炼手册网盘分享

download：笑傲 Java 面试：面霸修炼手册

Golang 泛型进步了编码效率
序
Golang 的泛型曾经进去一段时间了，大家应该对它有所理解，甚至在利用中应用过。尽管 Golang 的泛型性能简略，而且可能会减少代码的复杂度，然而适度应用也可能会升高代码的可读性。
但不可否认的是，泛型的确使咱们在应用 Golang 时可能提取一些罕用代码，防止代码的反复拷贝，进步代码性能 (防止类型转换)，进步编码效率和体验，进步代码可维护性。
本文次要介绍我用 Golang 泛型做了什么。
工具性能
尽管规范库中曾经提供了大量的工具函数，然而这些工具函数并不是由泛型实现的。为了改善体验，咱们能够通过泛型来实现它们。
比方经典的数学。Max()和数学。数值算法中的 Min()是 float64 类型，然而很多时候咱们应用这些类型的 int 和 int64。在 Golang 引入泛型之前，咱们常常依照如下类型来实现它们，从而产生了大量的模板代码:
func MaxInt(a，b int) int {
如果 a > b {
返回 a
}
返回 b
}

func MaxInt64(a，b int64) int64 {
如果 a > b {
返回 a
}
返回 b
}

//… 其余类型
复制代码
应用泛型时，咱们只须要一个实现:
func MaxT 束缚。有序 T {
如果 a > b {
返回 a
}
返回 b
}
复制代码
束缚在哪里。Ordered 示意可排序的类型，即 [>，=，
代码地址
其余如 json 解析、参数查看、切片等。也能够通过泛型实现。
数据结构
Golang 本人的通用容器是切片和地图。这两种数据结构实际上能够实现大部分工作，但有时咱们可能须要其余数据结构，比方优先级队列和链表。
尽管 Golang 在容器包下有堆、列表、环三种数据结构，然而用起来说实话不是很不便，尤其是元素类型都是接口 {}。应用这些构造须要各种类型转换。所以咱们能够简略地复制这些代码，而后用泛型对它们进行转换，比方 heap:
咱们不仅应用泛型来实现，还默认将 heap 改为 slice 来实现，所以咱们只须要实现一个 LessFunc 而不是五个。
包堆

类型 LessFunc[T any] func(e1 T，e2 T) bool

类型堆 [T any] 构造{
h []T
lessFunc
}

func NewT any *Heap[T] {
堆:= &Heap[T]{
h: h，
lessFunc: lessFunc，
}
heap.init()
返回堆
}

// 移除堆顶部元素
func (h *Heap[T]) Pop() T {
n := h.Len() – 1
h.swap(0，n)
h.down(0，n)
return h.pop()
}

// 获取堆顶部元素
func (h *Heap[T]) Peek() T {
返回 h.h[0]
}

// 向堆中增加元素
func (h *Heap[T]) Push(x T) {
h.push(x)
h.up(h.Len() – 1)
}
复制代码
代码地址
其余数据结构包含 list、set、pqueue 等。
模板代码
在后盾业务代码中，咱们常常会有很多业务处理函数，每个业务处理函数基本上都是由一些代码封装成一个 HTTP 接口。其实都是模板代码。例如，对于 gin 实现的 HTTP 服务，咱们须要如下解决每个接口:

指定 HTTP 办法、URL
证实
参数绑定
解决申请
反馈

能够发现参数绑定和解决响应简直都是同一个模板代码，认证根本都是模板代码 (当然有些认证可能比较复杂)。
因而，咱们能够编写一个通用模板，并提取雷同的局部。用户只须要用不同的接口实现指定的 HTTP 办法、URL 和申请解决逻辑:
// 解决申请
func doReq any，Rsp any，Opt any，
serviceFunc ServiceFunc[Req，Rsp]，serviceopttfunc serviceopttfunc[Req，Rsp，Opt]，opts…Opt) 杜松子酒。HandlerFunc {
返回函数 (c *gin。上下文){
// 参数绑定
req，err := BindJSONReq
如果 err！= 零 {
返回
}
// 进一步解决申请构造
if reqFunc！= 零{
申请函数
}
var rsp *Rsp
// 业务逻辑函数调用
if serviceFunc！= 零{
rsp，err = serviceFunc(c，req)
} else if serviceOptFunc！= 零{
rsp，err = serviceoptpfunc(c，req，opts…)
} 否则 {
panic(“ 必须设置 ServiceFunc 或 ServiceFuncOpt “)
}
// 解决响应
处理器 sp(c，Rsp，err)
}
}
复制代码
这样，当初一个接口基本上只须要一行代码就能够实现 (不包含具体的业务逻辑性能):
// 简略申请，不须要身份验证
e.GET(“/user/info/get “，ginrest。Do(nil，GetUserInfo))
// 身份验证、绑定 UID、解决
reqFunc := func(c gin。上下文，req UpdateUserInfoReq) {
申请。UID = GetUID(c)
}// 这里再多一步就是阐明第一个参数是 ReqFunc。
e.POST(“/user/info/update “，Verify，ginrest。Do(reqFunc，UpdateUserInfo))
复制代码
地址，并实现了一个基于 gin 的 RESTful 格调模板。
对象池 / 缓存
Golang 规范库附带了一个线程平安的高性能对象池同步。池，能够依据物体的热度主动开释物体。然而，作为对象池，咱们通常只放一种类型的对象进去，然而元素是同步的。池是接口{} 类型，所以咱们能够简略地封装 sync。池并使其元素具备特定的类型:
事实上，这里有一个简略的对象同步。Pool 进行打包，而后增加一个 ClearFunc()在回收对象时做一些清理操作。例如，咱们须要使字节片的应用长度为零 (容量放弃不变)。
// 创立一个新对象
键入 NewFunc[T any] func() T

// 清理对象
类型 ClearFunc[T any] func(T) T

类型 Pool[T any] struct {
p 同步。泳池
clearFunc
}

func NewT any* Pool[T]{
如果 newFunc == nil {
panic(“ 必须提供 NewFunc “)
}
p := &Pool[T]{
clearFunc: clearFunc，
}
p.p.New = func() any {
返回 newFunc()
}
返回 p
}

// 获取对象
func (p *Pool[T]) Get() T {
返回 p.p.Get()。(吨)
}

// 返回对象
func (p *Pool[T]) Put(t T) {
if p.clearFunc！= 零{
t = p.clearFunc(t)
}
投入产出
}
复制代码
用作字节数组对象池:
new func:= func()[]字节 {
返回 make([]字节，大小，下限)
}
clear func:= func(b[]字节)[]字节 {
return b[:0]
}
p := New(newFunc，clearFunc)
Bytes := p.Get() // 这里字节的类型是[]byte
页（page 的缩写）上传 (字节)
复制代码
代码地址
缓存也是如此。目前大部分的缓存库都是基于接口 {0} 或者 byte[]实现的，然而咱们还是更喜爱间接操纵特定的类型，所以咱们能够本人用泛型来实现 (或者转换) 一个缓存库。我还实现了一个通用的缓存策略库，其中蕴含 LRU、LFU、ARC、NearlyLRU、TinyLFU 等缓存策略。
摘要
如你所见，实际上 Golang 泛型次要提供了代码形象和封装的能力，使咱们可能编写更多可重用的代码，防止到处复制代码，从而进步代码的可维护性和可读性，并从防止类型转换中取得一点点性能晋升。