Go 语言切片(slice)

最后编辑于2024-12-24 17:59:36.8181215 +0800 CST

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片

你可以声明一个未指定大小的数组来定义切片：

go 
1var identifier []type

切片不需要说明长度。

或使用make()函数来创建切片:

go 
1var slice1 []type = make([]type, len)

也可以简写为

go 
1slice1 := make([]type, len)

也可以指定容量，其中capacity为可选参数。

go 
1make([]T, length, capacity)

这里 len 是数组的长度并且也是切片的初始长度。

切片初始化

go 
1s :=[] int {1,2,3 }

直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3

go 
1s := arr[:]

初始化切片s,是数组arr的引用

go 
1s := arr[startIndex:endIndex]

将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片

go 
1s := arr[startIndex:]

缺省endIndex时将表示一直到arr的最后一个元素

go 
1s := arr[:endIndex]

缺省startIndex时将表示从arr的第一个元素开始

go 
1s1 := s[startIndex:endIndex]

通过切片s初始化切片s1

go 
1s :=make([]int,len,cap)

通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片

len() 和 cap() 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

以下为具体实例：

go 
 1package main
 2
 3import "fmt"
 4
 5func main() {
 6   var numbers = make([]int,3,5)
 7
 8   printSlice(numbers)
 9}
10
11func printSlice(x []int){
12   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
13}

以上实例运行输出结果为:

bash 
1len=3 cap=5 slice=[0 0 0]

空(nil)切片

一个切片在未初始化之前默认为 nil，长度为 0，实例如下：

go 
 1package main
 2
 3import "fmt"
 4
 5func main() {
 6   var numbers []int
 7
 8   printSlice(numbers)
 9
10   if(numbers == nil){
11      fmt.Printf("切片是空的")
12   }
13}
14
15func printSlice(x []int){
16   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
17}

以上实例运行输出结果为:

bash 
1len=0 cap=0 slice=[]
2切片是空的

切片截取

可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound]，实例如下：

go 
 1package main
 2
 3import "fmt"
 4
 5func main() {
 6   /* 创建切片 */
 7   numbers := []int{0,1,2,3,4,5,6,7,8}   
 8   printSlice(numbers)
 9
10   /* 打印原始切片 */
11   fmt.Println("numbers ==", numbers)
12
13   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
14   fmt.Println("numbers[1:4] ==", numbers[1:4])
15
16   /* 默认下限为 0*/
17   fmt.Println("numbers[:3] ==", numbers[:3])
18
19   /* 默认上限为 len(s)*/
20   fmt.Println("numbers[4:] ==", numbers[4:])
21
22   numbers1 := make([]int,0,5)
23   printSlice(numbers1)
24
25   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
26   number2 := numbers[:2]
27   printSlice(number2)
28
29   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
30   number3 := numbers[2:5]
31   printSlice(number3)
32
33}
34
35func printSlice(x []int){
36   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
37}

执行以上代码输出结果为：

bash 
1len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
2numbers == [0 1 2 3 4 5 6 7 8]
3numbers[1:4] == [1 2 3]
4numbers[:3] == [0 1 2]
5numbers[4:] == [4 5 6 7 8]
6len=0 cap=5 slice=[]
7len=2 cap=9 slice=[0 1]
8len=3 cap=7 slice=[2 3 4]

append() 和 copy() 函数

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。

go 
 1package main
 2
 3import "fmt"
 4
 5func main() {
 6   var numbers []int
 7   printSlice(numbers)
 8
 9   /* 允许追加空切片 */
10   numbers = append(numbers, 0)
11   printSlice(numbers)
12
13   /* 向切片添加一个元素 */
14   numbers = append(numbers, 1)
15   printSlice(numbers)
16
17   /* 同时添加多个元素 */
18   numbers = append(numbers, 2,3,4)
19   printSlice(numbers)
20
21   /* 创建切片 numbers1 是之前切片的两倍容量*/
22   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
23
24   /* 拷贝 numbers 的内容到 numbers1 */
25   copy(numbers1,numbers)
26   printSlice(numbers1)   
27}
28
29func printSlice(x []int){
30   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
31}

以上代码执行输出结果为：

bash 
1len=0 cap=0 slice=[]
2len=1 cap=2 slice=[0]
3len=2 cap=2 slice=[0 1]
4len=5 cap=8 slice=[0 1 2 3 4]
5len=5 cap=16 slice=[0 1 2 3 4]