Go语言——slice
[TOC]
一、切片介绍
切片是一种数据结构,这种数据结构便于使用和管理数据集合。切片是围绕动态数组的概念构建的,可以按需自动增长和缩小。切片的动态增长是通过内置函数 append 来实现的。这个函数可以快速且高效地增长切片。还可以通过对切片再次切片来缩小一个切片的大小。因为切片的底层内存也是在连续块中分配的,所以切片还能获得索引、迭代以及为垃圾回收优化的好处。
切片是引用类型,指向底层数组,切片语法和数组很像,只是没有长度而已。slice底层是连续内存,动态增加长度其实如果超过底层数组容量,也会重新分配内存。
- 指向底层的数组,作为变长数组的替代方案,可以关联底层数组的局部或全部
- slice 为引用类型,但自身是结构体,值拷贝传递。
- 如果多个slice指向相同底层数组,其中一个的值改变会影响全部
- 可以直接创建或从底层数组获取生成,一般使用make()创建
- make([]T, len, cap) ,其中cap可以省略,则和len的值相同。
- 属性 len 表示可用元素数量,读写操作不能超过该限制。
- 属性 cap 表示最⼤扩张容量,不能超出数组限制。
- 如果 slice == nil,那么 len、 cap 结果都等于 0。
二、内部实现和原理
struct Slice{ // must not move anything
byte* array; // actual data
uintgo len; // number of elements
uintgo cap; // allocated number of elements
};
切片是有 3 个字段的数据结构 ,这 3 个字段分别是指向底层数组的指针、切片访问的元素的个数(即长度)和切片允许增长到的元素个数(即容量)。
可以看出,slice是引用类型。时刻注意一点,slice传递的时候也是值拷贝,把slice的指针,长度,容量拷贝过去,那么同样可以去操作底层数组
三、创建和初始化
1、普通初始化(var或者:= ,字面量)
var slice[]int //只声明一个slice,len 和 cap 都是0
var slice0 []int=[]int{1,2,3}//完整声明,字面量初始化
var slcie1=[]int{1,2,3} //直接var 字面量初始化
slice2:=[]int{1,2,3}//函数内部可以用:=替代var 初始化
2、使用make() 函数进行初始化
一般使用make()进行创建 make([]T, len, cap) 指定类型,长度,容量,make()会在按照容量分配内存空间,也就是分配的数组
slice:=make([]string,5)//使用长度声明一个字符串切片,长度、容量都是5
slice0:=make([]int,3,5)//使用长度和容量声明int切片,长度为3,容量为5
容量小于长度的切片会在编译时报错
slice := make([]int, 5, 3)//注意,不允许,
注意:使用make([]int,3,5)创建slice,指定的容量cap 其实就是初始化的底层数组的长度。但是此slice 长度为3,只能操作底层数组的前3个,后两个是不能操作的,但是可以通过append函数添加到此slice中。如果基于这个切片创建新的切片,新切片会和原有切片共享底层数组,也能通过后期操作(如append)来访问多余容量的元素。
3、使用索引声明切片
// 创建字符串切片
// 使用空字符串初始化第 100 个元素
slice := []string{99: ""}
记住,如果在[]运算符里指定了一个值,那么创建的就是数组而不是切片。只有不指定值的时候,才会创建切片 。这里字面量声明索引为99的位置为空字符串,所以,长度和容量都是 100 个元素,最少开辟了100个内存空间。
4、从数组创建slice
(1)通过两个冒号创建切片,slice[x:y:z]
切片实体[x:y]
切片长度len = y-x
,切片容量cap = z-x
data := [...]int{0, 1, 2, 3, 4, 5, 6} //初始化一个数组
slice := data[1:4:5] // [low : high : max] 通过两个冒号创建切片
使用两个冒号[1:4:5] 从数组中创建切片,长度为4-1=3,也就是索引从1到3 的数据(1,2,3),然后,后面是最大是5,即容量是5-1=4,即,创建的切片是长度为从索引为 1、2、3 的切片,底层数组为[ 1,2,3,4]
(2)通过单个冒号,索引创建slice
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
expression slice len cap comment
------------+----------------------+------+-------+---------------------
data[:6:8] [0 1 2 3 4 5] //6 8 省略 low.
data[5:] [5 6 7 8 9] //5 5 省略 high、 max。
data[:3] [0 1 2] //3 10 省略 low、 max。
data[:] [0 1 2 3 4 5 6 7 8 9] //10 10 全部省略。
5、创建空的slice
首先说一下,slice和array的区别,其实就是[]中有没有值,有值就是数组,无值就是slice
// 使用 make 创建空的整型切片
slice := make([]int, 0)
// 使用切片字面量创建空的整型切片
slice := []int{}
空切片在底层数组包含 0 个元素,也没有分配任何存储空间。想表示空集合时空切片很有用.
例如,数据库查询返回 0 个查询结果时
四、切片的使用
1、直接用索引赋值
// 创建一个整型切片
// 其容量和长度都是 5 个元素
slice := []int{10, 20, 30, 40, 50}
// 改变索引为 1 的元素的值
slice[1] = 25
2、reslice 也就是通过slice创建 slice
s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] // [2 3 4]
s2 := s1[2:6:7] // [4 5 6 7]
s3 := s2[3:6] // Error。 不能超过父slice的容量。
//索引s[2:5] 表示从索引2开始,到索引4结束,包括2但是不包括5
- s1:=s[2:5] 得到的是len为 5-2=3, cap为10-2=8。 这个公式 可以计算。 所以,s1指向底层数组的从第二个索引开始,三个长度的内存,2,3,4. 但是他的容量cap为8,也就是,s1指向内存起始位置是原数组的2,一直到9,都是一块连续的内存。如果要增加s1的长度,不需要开辟新的内存空间,只需要往s1里面添加就行,他继续指向这块内存地址,直到他的长度超过容量,就会重新开辟内存空间。
- s2:=s1[2:6:7] ,s2是通过s1创建的新的slice,它同样指向了和s1,s1一样的底层数组,只不过是起始的索引位置不同。s2表示从s1索引为2开始到索引为5的长度为4个的slice,并且还指定了他的容量为7,也就是它不使用它起始索引到底层数组末尾的长度作为容量,而是使用自己指定的容量7. 如图,s1长度为3,而s2的长度为4,并且是从s1索引为2开始的,但是却没有报错。 是因为,reslice,是根据 子slice相对于父slice的容量创建的,只要子slice的长度没有超过父slice的容量,那么就是允许的,因为他们指向的是同一个底层数组。
- 所以,s3:=s2[3:6] 他报错了。因为s3是创建 从s2作为为3,长度为3的slice,但是s2的长度为4,容量为5,从索引3开始算,s2只能最大创建出长度为2的 子slice,不能创建出长度为3的slice
- 总结下,就是,父slice 和子slice 都是指向了同一块连续内存,底层是个数组。 只是根据长度和容量的不同,创建的slice 允许操作的内存块是不同的。如果子slice创建时不指定自己的容量cap,那么它的容量默认为,从他指向的那个底层数组的索引开始,一直到这个数组的最末端。这块是它的容量,也就是它创建以后,可以继续扩展而不改变内存地址。注意,它可以操作的连续内存是由它的长度决定的。比如,长度为3,容量为5,的slice,它只能操作从它指向底层数组的那个首索引开始,往后三个数,另外两个是不允许操作的。
由于reslice 的slice指向了同一块连续内存空间,所以操作是会相互影响的
// 创建一个整型切片
// 其长度和容量都是 5 个元素
slice := []int{10, 20, 30, 40, 50}
// 创建一个新切片
// 其长度是 2 个元素,容量是 4 个元素 {20,30}
newSlice := slice[1:3]
// 修改 newSlice 索引为 1 的元素
// 同时也修改了原来的 slice 的索引为 2 的元素
newSlice[1] = 35
//最终底层为 {10,35,30,40,50}
3、append 增长slice
相对于数组而言,使用切片的一个好处是,可以按需增加切片的容量。 函数 append 总是会增加新切片的长度,而容量有可能会改变,也可能不会改变,这取决于被操作的切片的可用容量。 (也就是,如果容量够直接加,不够重新分配内存,拷贝原数组加)
(1)append 没有超过原始slice的容量,不会开辟新的内存空间
s := make([]int, 0, 5)
fmt.Printf("%p\n", &s)
s2 := append(s, 1)
fmt.Printf("%p\n", &s2)
fmt.Println(s, s2)
//输出结果-----这说明了,只要容量够,增长前和增长后指向的内存地址是一样的。同时改变了底层数组的值
0xc000004440
0xc000004480
[] [1]
append函数做的事就是更改slice指向底层数组的值
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[:3]
s2 := append(s, 100, 200) // 添加多个值。
fmt.Println(data)
fmt.Println(s)
fmt.Println(s2)
//输出----------append函数更改了slice执行底层数组data,增加了s的长度,并将相应位置的值改变
[0 1 2 100 200 5 6 7 8 9]
[0 1 2]
[0 1 2 100 200]
(2)但是,一旦超出原 slice.cap 限制,就会重新分配底层数组,即便原数组并未填满。
data := [...]int{0, 1, 2, 3, 4, 10: 0}
s := data[:2:3]
s = append(s, 100, 200) // ⼀次 append 两个值,超出 s.cap 限制。
fmt.Println(s, data) // 重新分配底层数组,与原数组无关。
fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。
//输出
[0 1 100 200] [0 1 2 3 4 0 0 0 0 0 0]
0xc00007e030 0xc00004a060
上面代码表示,切片s 的长度为2,容量为3,而s通过append一次性添加两个值,也就是想把s变为长度为4的切片,这超过了s的原始容量,所以,这样append会重新开辟一段内存地址,长度为4,容量为4。可以看大他们的内存地址是不一样的。
(3)append超过容量时,通常以两倍的方式来开辟新的内存
s := make([]int, 0, 1)
c := cap(s)
for i := 0; i < 50; i++ {
s = append(s, i)
if n := cap(s); n > c {
fmt.Printf("cap: %d -> %d\n", c, n)
c = n
}
}
//输出
cap: 1 -> 2
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64
在大批量添加数据时,建议一次性分配足够大的空间,以减少内存分配和数据复制开销。或初始化足够长的 len 属性,改用索引号进行操作。及时释放不再使用的 slice 对象,避免持有过期数组,造成 GC 无法回收。
但是如果是要避免多个slice同时操作统一内存出现错误时,就需要将将slice创建为长度=容量,避免append新slice指向同一内存操作数据,具体情况根据实际灵活选择。
(5)将一个切片追加到另一个切片 ,使用...运算符
// 创建两个切片,并分别用两个整数进行初始化
s1 := []int{1, 2}
s2 := []int{3, 4}
// 将两个切片追加在一起,并显示结果
fmt.Printf("%v\n", append(s1, s2...)) //使用... 就可以
//输出:
[1 2 3 4]
//就像通过输出看到的那样,切片 s2 里的所有值都追加到了切片 s1 的后面。使用 Printf时用来显示 append 函数返回的新切片的值
4、使用for range 迭代slice
// 创建一个整型切片
// 其长度和容量都是 4 个元素
slice := []int{10, 20, 30, 40} // 迭代每一个元素,并显示其值
for i, v := range slice {
fmt.Printf("Index: %d Value: %d\n", i, v)
}
//输出
Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40
关键字 range 会返回两个值。第一个值是当前迭代到的索引位置,第二个值是该位置对应元素值的一份拷贝
// 创建一个整型切片
// 其长度和容量都是 4 个元素
slice := []int{10, 20, 30, 40}
// 迭代每个元素,并显示值和地址
for index, value := range slice {
fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n",
value, &value, &slice[index])
}
//输出:-----明显看出内存地址不同,所以这里的v,是拷贝,其实只是一个内存地址不断更新存不同的拷贝
Value: 10 Value-Addr: C000058058 ElemAddr: C0000560C0
Value: 20 Value-Addr: C000058058 ElemAddr: C0000560C8
Value: 30 Value-Addr: C000058058 ElemAddr: C0000560D0
Value: 40 Value-Addr: C000058058 ElemAddr: C0000560D8
因为迭代返回的变量是一个迭代过程中根据切片依次赋值的新变量,所以 value 的地址总是相同的。要想获取每个元素的地址,可以使用切片变量和索引值
迭代返回索引和位置非常有用,如果我们只想用其中一个,可以通过占位符 “_” 操作
slice := []int{10, 20, 30, 40}
for _, value := range slice {// 迭代每个元素,并显示其值,通过占位符,不需要得到索引
fmt.Printf("Value: %d\n", value)
}
//输出:
Value: 10
Value: 20
Value: 30
Value: 40
5、copy 复制slice
函数 copy 在两个 slice 间复制数据,复制长以 len 小的为准。两个 slice 可指向同一底层数组,允许元素区间重叠。
(1)不指定位置
s1 := []int{1, 2, 3, 4, 5, 6}
s2 := []int{7, 8, 9}
fmt.Println(s2)
copy(s2, s1) //将s1 copy到 s2, 谁的长度小听谁的,此处只能拷贝前三个
fmt.Println(s2)
//输出------长度大的往长度小的复制最大只能复制以小长度为准的位数
[7 8 9]
[1 2 3]
(2)指定位置
还可以指定复制slice 和被复制slice 的位置进行copy,不指定默认从前往后,如上面代码
s1 := []int{0,1, 2, 3, 4, 5, 6}
s2 := []int{7, 8, 9}
fmt.Println("s1=",s1)
fmt.Println("s2=",s2)
copy(s1[4:6], s2[1:3]) //将s2指定位置复制到s1指定的位置
fmt.Println("s1=",s1)
//输出
s1= [0 1 2 3 4 5 6]
s2= [7 8 9]
s1= [0 1 2 3 8 9 6]
(3)注意,copy以后的数组,指向的底层数组也会随之改变
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := data[8:]
s2 := data[:5]
copy(s2, s) // dst:s2, src:s
fmt.Println(s2)
fmt.Println(data)
//输出
[8 9 2 3 4]
[8 9 2 3 4 5 6 7 8 9]
6、切片的传递
切片的传递,都是值传递,是切片的拷贝
在 64 位架构的机器上,一个切片需要 24 字节的内存:指针字段需要 8 字节,长度字段需要8字节,容量字段需要 8 字节。由于与切片关联的数据包含在底层数组里,不属于切片本身,所以将切片复制到任意函数的时候,对底层数组大小都不会有影响。复制时只会复制切片本身,不会涉及底层数组 。所以不管多大的slice,值传递都不会影响性能。
五、多维切片
多维欺骗和多维数组差不多,只不过[]没有值
// 创建一个整型切片的切片
slice := [][]int{{10}, {100, 200}}
使用append 给slice[0]进行增长,查看内存变化
// 创建一个整型切片的切片
slice := [][]int{{10}, {100, 200}}
// 为第一个切片追加值为 20 的元素
slice[0] = append(slice[0], 20)
以上代码会先增长切片,会为新的整型切片分配新的底层数组,然后将切片复制到外层切片的索引为 0 的元素
有疑问加站长微信联系(非本文作者)