携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第21天，点击查看活动详情

切片

切片是Go中重要的数据类型，每个切片对象内部都维护着：数组指针、切片长度、切片容量三个数据。

type slice struct{
    array unsafe.Pointer
    len int
    cap int
}

在向切片中追加的数据个数大于容量时，内部会自动扩容且每次扩容都当前容量的2倍（当容量超过1024时每次扩容则只增加1/4容量)

声明

三种方式

//1、创建切片
var nums []int
//2、初始化创建
var data1 = []int{1, 2, 3}
data2 := []int{1, 2, 3}
//3、make用于切片、字典、channel
var data3 = make([]int, 1, 3)   //长度为1，内存为3
​
fmt.Println(nums)
fmt.Println(data1)
fmt.Println(data2)
fmt.Println(data3)

结果：

[]
[1 2 3]
[1 2 3]
[0]

自动扩容

Demo1

//len=1、cap=3
v1 := make([]int, 1, 3)
fmt.Println(len(v1), cap(v1))
//len=3、cap=3
data := make([]int, 3)
fmt.Println(len(data), cap(data))

结果：

1 3
3 3

Demo2

v1 := make([]int, 1, 3)
v2 := append(v1, 66)
fmt.Println(v1)
fmt.Println(v2)

结果：

[0]
[0 66]

通过append追加后，v1,v2使用的是同一内存地址，当v1的值改变后v2也会随着改变

v1 := make([]int, 1, 3)
v2 := append(v1, 66)
fmt.Println(v1)
fmt.Println(v2)
​
v1[0] = 999
fmt.Println(v1)
fmt.Println(v2)

结果：

[0]
[0 66]
[999]
[999 66]

可以看到值修改了v1[0]的值，v2的第一位也变成了999

append也可以不赋值给其他变量，此时就代表给当前变量追加一个值

v3 := make([]int, 1, 3)
v3 = append(v3, 999)
fmt.Println(v3)         //[0 999]

Demo3

v1 := []int{1, 2, 3}
v2 := append(v1, 4)
​
v1[0] = 999
fmt.Println(v1, len(v1), cap(v1))
fmt.Println(v2, len(v2), cap(v2))

结果：

[999 2 3] 3 3
[1 2 3 4] 4 6

v1声明后默认容量为3，当追加一个值后，就会发生扩容，将容量阔成当前的两倍所以变成了6，而此时v2的内存地址就发生了改变，所以当给v1[0]赋值后，v2并没有改变

常见操作

长度和容量

v1 := []int{1, 2, 3}
fmt.Println(len(v1), cap(v1))

索引

v1 := []int{1, 2, 3}
fmt.Println(v1[2])
​
v2 := make([]int, 2, 5)
fmt.Println(v2[2])       //报错，因为长度设置为2，所以索引只能到1

切片

v1 := []int{1, 2, 3}
v2 := v1[0:1]
v3 := v1[1:]
v4 := v1[:2]
​
fmt.Println(v2)
fmt.Println(v3)
fmt.Println(v4)

追加

v1 := []int{1, 2, 3}
v2 := append(v1, 4)
fmt.Println(v2)

删除

其实就相当于切片拆分后拼接

v1 := []int{1, 2, 3, 4, 5}
deleteIndex := 2 //删除索引为2的数
resault := append(v1[:deleteIndex], v1[deleteIndex+1:]...)
fmt.Println(resault)
fmt.Println(v1)

结果：

[1 2 4 5]
[1 2 4 5 5]

通过结果可以看出 ，v1 本身是[1 2 3 4 5 ]，但经过拼接后变 成了[1 2 4 5 5]，切片拼接后由于使用的是原先的内存地址 ，所以会修改原变量v1的值，因此这种方式效率低下并不常用

插入

在索引为3的位置插入99

v1 := []int{1, 2, 3, 4, 5}
insertIndex := 3         //在索引为3的位置插入99
​
resault := make([]int, 0, len(v1)+1)
resault = append(resault, v1[:insertIndex]...)
resault = append(resault, 99)
resault = append(resault, v1[insertIndex:]...)
fmt.Println(resault)

这种方式不是在原有v1上进行追加，所以就不会上边的值被覆盖的现象

循环

切片就可以理解为变长的数组，所以这个地方的循环就跟数组部分的一样了

for循环

v1 := []int{1, 2, 3, 4, 5}
for i := 0; i < len(v1); i++ {
   fmt.Printf("%v", v1[i])
}

for range循环

v1 := []int{1, 2, 3, 4, 5}
for _, i := range v1 {
   fmt.Printf("%v", i)
}

嵌套

应该可以理解为多维切片

v1 := []int{1, 2, 3}
v2 := [][]int{[]int{1, 2, 3, 4}, []int{5, 6}}
v3 := [][2]int{[2]int{1, 2}, [2]int{3, 4}}
fmt.Println(v1)
fmt.Println(v2)
fmt.Println(v3)
​
fmt.Println("------------------")
​
v1[0] = 111
v2[0][1] = 2222
v3[1][0] = 333
fmt.Println(v1)
fmt.Println(v2)
fmt.Println(v3)

结果：

[1 2 3]
[[1 2 3 4] [5 6]]
[[1 2] [3 4]]
------------------
[111 2 3]
[[1 2222 3 4] [5 6]]
[[1 2] [333 4]]

\