【新人系列】Golang 入门（四）：集合类型

✍ 个人博客：https://blog.csdn.net/Newin2020?type=blog
📝 专栏地址：https://blog.csdn.net/newin2020/category_12898955.html
📣 专栏定位：为 0 基础刚入门 Golang 的小伙伴提供详细的讲解，也欢迎大佬们一起交流~
📚 专栏简介：在这个专栏，我将带着大家从 0 开始入门 Golang 的学习。在这个 Golang 的新人系列专栏下，将会总结 Golang 入门基础的一些知识点，并由浅入深的学习这些知识点，方便大家快速入门学习~
❤️ 如果有收获的话，欢迎点赞 👍 收藏 📁 关注，您的支持就是我创作的最大动力 💪

本章节会重点介绍 slice 数组，由浅入深带大家看看 slice 底层是如何实现的。

1. 数组

定义：

//一维数组
var name [count]int

//多维数组

var courseInfo [3][4]string

初始化：

/* 一维数组 */
//方法1
coures1 := [3]string{"go", "grpc", "gin"}//方法2
courses2 := [3]string{2:"gin"}//方法3
courses3 := [...]string{"go", "grpc", "gin"}/* 多维数组 */
var courseInfo [3][4]string//方法1
courseInfo[0] = [4]string{"go", "1h", "bobby", "go学习"}//方法2
courseInfo[0][0] = "go"
courseInfo[0][1] = "1h"
courseInfo[0][2] = "bobby"
courseInfo[0][3] = "go学习"

遍历：

/* 一维数组 */
//方法1
for i := 0; i < len(courses); i++ {fmt.Println(courses[i]}
}//方法2
for _, value := range courses {fmt.Println(value)
}/* 多维数组 */
//方法1
for i := 0; i < len(courseInfo); i++ {for j:=0; j < len(courseInfo[i]); j++ {fmt.Print(courseInfo[i][j] + " ")}fmt.Println();
}//方法2
for _, row := range courseInfo {fmt.Println(row)
}

注意：

[2]string 和 [3]string 是不同的类型
[count]string 是数组，[]string 是切片

2. slice

2.1 定义与初始化

定义：

var courses []string

初始化：

//方法1 - 从数组直接创建 (也可以通过切片创建新的切片)
courses := [5]string{"go", "grpc", "gin", "mysql", "elasticsearch"}
courseSlice := courses[0:2]    //[go, grpc]//方法2 - 使用string{}
courses := []string{"go", "grpc", "gin", "mysql", "elasticsearch"}//方法3 - make
courses := make([]string, 3)
courses[0] = "go"//方法3 - append
var courses []string
courses = append(courses, "go")

注意：
切片数组是左闭右开区间

2.2 常用操作

增加元素：

var courses []string//场景1 - 增加单个元素
courses = append(courses, "go")//场景2 - 增加多个元素
courses = append(coureses, "go", "grpc")//场景3 - 增加切片到尾部
courseSilce1 := []string{"go", "grpc"}
courseSilce2 := []string{"mysql", "es"}
courseSilce1 = append(courseSilce1, courseSilce2...)

删除元素：

courseSlice := []string{"go", "grpc", "mysql", "es", "gin"}
//删除mysql
myslice := append(courseSlice[:2], courseSlice[3:]...)

拷贝：

//浅拷贝 - 切片2改动会影响到切片1
courseSlice2 = courseSlice1[:]//深拷贝 - 切片2改动不会影响到切片1
var courseSlice2 = make([]string, len(courseSlice1))
copy(courseSlice2, courseSlice1)

2.3 底层存储原理

//切片的实际存储类型
type slice struct {array unsafe.Pointer    //用来存储实际数据的数组指针，指向一块连续的内存len   int               //切片中元素的数量cap   int               //array数组的长度
}

在这里插入图片描述
下面我们分场景举两个例子：

整形

如果我们用 make 来初始化的话，则会分配实际的内存，并且会将元素全部初始化为 0，例如下面我们创建了 5 个大小的空间，但访问的只有前 2 个。

在这里插入图片描述

假设我们现在新增一个元素，并更改其中一个元素的值，可以发现容量没变但实际长度变成了 3，但需要注意的是后面两个元素仍不能访问，否则汇报数组越界的错误。

在这里插入图片描述
2. 字符串

这次我们用 new 来初始化，与 make 不同，new 虽然会创建上面的三部分结构，但并不会分配底层数组空间，所以 data 为 nil。因此，如果我们试图更改数组的值比如 (*ps)[0] = “golang”，则会报错。

在这里插入图片描述

但是，我们可以通过 append 的方式来分配底层数组

在这里插入图片描述

2.4 分配位置

可以发现，我们上面举的例子中 slice 的 data 指针都指向 array 数组的第一个元素，但实际上 slice 可以指向 array 数组的任何一个位置。

注意：
array 数组一旦申明了容量大小就不可改变，因此我们可以通过 slice 来灵活的获得我们想要的数组变量。

来举个例子：

下面需要注意的是，s1 的容量计算范围是从开头到底层数组的结尾，因此其容量为 9。

在这里插入图片描述

注意：
切片是值传递，但是有引用传递的效果，是因为底层都指向同个地方。一旦增加导致扩容，会指向另一块区域。

我们这里拿 s2 切片数组进行模拟，一旦切片数组发生扩容，则会重新分配一块新的内存，此后对该切片数组的操作都不会再影响到原来的底层数组。

在这里插入图片描述

2.5 扩容规则

go1.18 之前：

在这里插入图片描述

// src/runtime/slice.gofunc growslice(et *_type, old slice, cap int) slice {// ...newcap := old.capdoublecap := newcap + newcapif cap > doublecap {newcap = cap} else {if old.cap < 1024 {newcap = doublecap} else {// Check 0 < newcap to detect overflow// and prevent an infinite loop.for 0 < newcap && newcap < cap {newcap += newcap / 4}// Set newcap to the requested cap when// the newcap calculation overflowed.if newcap <= 0 {newcap = cap}}}// ...return slice{p, old.len, newcap}
}

go1.18 之后：

在这里插入图片描述

// src/runtime/slice.gofunc growslice(et *_type, old slice, cap int) slice {// ...newcap := old.capdoublecap := newcap + newcapif cap > doublecap {newcap = cap} else {const threshold = 256if old.cap < threshold {newcap = doublecap} else {// Check 0 < newcap to detect overflow// and prevent an infinite loop.for 0 < newcap && newcap < cap {// Transition from growing 2x for small slices// to growing 1.25x for large slices. This formula// gives a smooth-ish transition between the two.newcap += (newcap + 3*threshold) / 4}// Set newcap to the requested cap when// the newcap calculation overflowed.if newcap <= 0 {newcap = cap}}}// ...return slice{p, old.len, newcap}
}

举个例子：

func main() {ints := make([]int, 2)fmt.Println(&ints[0], " len: ", len(ints), " cap: ", cap(ints))ints = append(ints, 2, 3, 4)fmt.Println(&ints[0], " len: ", len(ints), " cap: ", cap(ints))
}output
>>> 0xc0000180a0  len:  2  cap:  2
>>> 0xc00000a360  len:  5  cap:  6