如果说GO语言的数组为静态长度的数组,那么切片(slice)则为动态长度的数组

一、基于数组创建切片

1、存在一个整型数组intArr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},那么下面的slice就是数组切片

var slice []int = intArr[3:7]

【Go语言】【7】GO语言的切片_切片

从图中可以看出切片从数组的第4个元素开始读取数据,直至第8个元素(但不包含第8个)。切记程序员的计数都是从0开始的哟【Go语言】【7】GO语言的切片_切片_02


2、若只读intArr数组的前4个元素,该如何办呢?聪明的你一定能想到

var slice [] int = intArr[0:4]

或者

slice := intArr[0:4]


3、是否还有更简洁的表示吗?那肯定了,GO这么懂程序员

slice := intArr[:4],它与slice := intArr[0:4]等价


4、哪些读取intArr数组第4个元素(包含第4个元素)之后的所有数据呢?

slice := intArr[3:10]

当然也可以如下表示

slice := intArr[3:len(intArr)]

或者

slice := intArr[3:]


二、基于数组创建的切片与该数组的关系

上例中基于数组intArr创建了切片slice,那么slice与intArr有什么关系呢?可以简单地理解为切片是在数组的基础上增加了一些管理功能,很类型C++中的数组与std::vector的关系。

intArr := [10]int{1,2,3,4,5,6,7,8,9,10} // 定义数组intArr

var slice []int = intArr[3:7]        // 基于intArr创建切片 


fmt.Printf("intArr的地址是: %p\n", &intArr) 

fmt.Printf("slice的地址是 : %p\n", &slice)


fmt.Printf("intArr的第4个元素地址是: %p\n", &intArr[3])

fmt.Printf("slice的第1个元素地址是 : %p\n", &slice[0])【Go语言】【7】GO语言的切片_切片_03

从程序运行结果上可以看切片slice和数组intArr两者没有任何关系,是不同的内在地址;但有意思的是切片slice的第一个元素地址恰恰是数组intArr的第4个元素地址,这不是巧合,而是切片的实质

【Go语言】【7】GO语言的切片_GO_04

所以有人也说切片是指向数组的指针,对切片元素的更改会影响数组元素的值,这个通过改写上面示例可以得到验证:

intArr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

slice := intArr[3:]

slice[0] = 100 // 更改切片的第1个元素值为100

fmt.Println("slice=", slice)

fmt.Println("intArr=", intArr)

【Go语言】【7】GO语言的切片_切片_05


三、基于切片创建切片

能否基于切片创建切片呢?答案是肯定的,其使用方法与基于数组创建切片相同

intArr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

slice := intArr[3:]

reslice := slice[1:]

fmt.Println(reslice)

【Go语言】【7】GO语言的切片_切片_06

由于slice是基于数组intArr创建的切片,它从intArr的第4个值开始,所以slice的值为[4,5,6,7,8,9,10]; 而reslice是基于切片slice创建的切片,它从slice的第2个值开始,所以reslice的值为[5,6,7,8,9,10]


四、直接创建切片

并不是非得基于数组或者切片才能创建切片,GO语言很贴心地为程序员提供了make()函数,其形式为slice := make([] type, number, capacity),例如:

slice := make([]int, 3, 10)

1、number和capacity分别是什么意思?

number是切片元素个数,创建切片slice之后,里面有几个元素;capacity表示切片的容量,创建切片slice之后,先预留10个元素的存储空间。运行上面例子便能理解:

【Go语言】【7】GO语言的切片_切片_07

从结果上来看,切片slice元素个数为3,且元素缺省填充为0;由于切片slice的容量为10,所以还可以向切片追加7个元素。


2、len()和cap()

切片有len()和cap()函数,分别用来获取切片的元素个数和容量值,例如:

slice := make([]int, 3, 10)

num := len(slice)

capacity := cap(slice)

fmt.Println("切片slice元素个数为:", num, ",容量为:", capacity)

【Go语言】【7】GO语言的切片_切片_08


3、能省略容量吗?

答案是OK的,所以可以这样声明切片:slice := make([]int,3)

那么此时它的容量与元素个数相同,即为3


4、能把元素个数和容量都省略变为slice := make([]int)可行吗?

答案是NO,此时GO语言就晕了,它在想难道程序员让我把所有内存都占用?就抛出missing len argument to make([]int)错误信息


5、只有类型和容量,省略元素个数呢,类似slice := make([]int,,10)

答案是NO【Go语言】【7】GO语言的切片_GO_09,但可以声明后直接初始化,即slice := []int{1,2,3,4,5,6}【Go语言】【7】GO语言的切片_切片_10


6、如何追加元素?

slice := make([]int, 3, 10)

fmt.Println("切片slice元素个数为:", len(slice), ",容量为:", cap(slice), ",slice=", slice)

可以这样追加:

slice = append(slice, 4)

slice = append(slice, 5)

也可以这样追加:

slice = append(slice, 6, 7, 8)

甚至可以追加一个切片,但在后面必须添加...

arr := [2]int{9, 10}

slice = append(slice, arr...)

程序运行追加后的结果如下:

【Go语言】【7】GO语言的切片_GO_11


五、切片追加元素后切片是否重新生成?

1、追加说明

slice := make([]int, 3, 10) // 声明一个切片

fmt.Printf("原切片的地址%p\n", &slice)

fmt.Printf("原切片第一个元素的地址%p\n", &slice[0])


slice = append(slice, 4)  // 追加一个元素

fmt.Printf("新切片的地址%p\n", &slice)

fmt.Printf("新切片第一个元素的地址%p\n", &slice[0])

【Go语言】【7】GO语言的切片_切片_12

从运行结果上可以看到,追加一个元素后,切片元素的地址并没有发生变化;但在应用时必须返回值赋给slice,即下面的程序是错误的:

slice := make([]int, 3, 10) 

append(slice, 4) // 必须返回slice

fmt.Printf("%p\n", &slice)


2、追加超过容量大小

slice := make([]int, 3, 10)                   // 切片容量为10

fmt.Printf("%p\n", &slice)                    // 打印切片地址

fmt.Println("len:", len(slice), "cap:", cap(slice))   // 打印切片元素个数和容量


slice = append(slice, 4, 5, 6, 7, 8, 9, 10, 11)      // 切片追加元素

fmt.Printf("%p\n", &slice)                    // 打印切片地址

fmt.Println("len:", len(slice), "cap:", cap(slice))   // 打印切片元素个数和容量

这个例子中一开始声明了容量为10的切片,当向切片中追加元素时,使其元素个数超过容量,此时切片会自动扩展容量一倍变为20,这点与Java的集合很相似
【Go语言】【7】GO语言的切片_GO_13