上面小节，我们学习的 Go 语言数组 ，本小节我们讲讲切片。
一、什么是切片
切片和数组类似，都是数据集合。和数组不同的是，切片是一块动态分配大小的连续空间。它和 Java 语言中的 AarryList 集合类似。
二、声明切片
切片的声明格式如下:
var name []T
name下面是示例代码:
package main
import "fmt"
func main() {
// 声明整型切片
var numList []int
// 声明字符串切片
var strList []string
// 声明一个空切片, {} 表示已经分配内存，但是切片里面的元素是空的
var numListEmpty = []int{}
// 输出3个切片
fmt.Println(numList, strList, numListEmpty)
// 输出3个切片大小
fmt.Println(len(numList), len(strList), len(numListEmpty))
// 切片判定是否为空结果
fmt.Println(numList == nil)
fmt.Println(strList == nil)
fmt.Println(numListEmpty == nil)
}
代码输出:
[] [] []
0 0 0
true
true
false
图示：
go语言切片代码示例
三、使用 make() 函数构造切片
make()make( []T, size, cap )
Tsizecap示例代码如下:
package main
import "fmt"
func main() {
a := make([]int, 4)
b := make([]int, 4, 10)
fmt.Println(a, b)
fmt.Println(len(a), len(b))
}
代码输出如下:
[0 0 0 0] [0 0 0 0]
4 4
a 和 b 切片均为大小为 2， 不同的是 b 内存空间预分配了 10 个，但是实际只使用了 2 个元素。
len()四、使用 append() 函数为切片添加元素
append()package main
import "fmt"
func main() {
// 声明一个字符串类型的切片
var strList []string
// 循环动态向 strList 切片中添加 20 个元素，并打印相关参数
for i := 0; i < 10; i++ {
line := fmt.Sprintf("quanxiaoha %d", i)
strList = append(strList, line)
fmt.Printf("len: %d, cap: %d, pointer: %p, content: %s\n", len(strList), cap(strList), strList, strList[i])
}
}
代码输出如下:
len: 1, cap: 1, pointer: 0xc00008e1e0, content: quanxiaoha 0
len: 2, cap: 2, pointer: 0xc0000a6040, content: quanxiaoha 1
len: 3, cap: 4, pointer: 0xc0000b2040, content: quanxiaoha 2
len: 4, cap: 4, pointer: 0xc0000b2040, content: quanxiaoha 3
len: 5, cap: 8, pointer: 0xc0000bc000, content: quanxiaoha 4
len: 6, cap: 8, pointer: 0xc0000bc000, content: quanxiaoha 5
len: 7, cap: 8, pointer: 0xc0000bc000, content: quanxiaoha 6
len: 8, cap: 8, pointer: 0xc0000bc000, content: quanxiaoha 7
len: 9, cap: 16, pointer: 0xc0000be000, content: quanxiaoha 8
len: 10, cap: 16, pointer: 0xc0000be000, content: quanxiaoha 9
len()capappend()append()package main
import "fmt"
func main() {
var strList []string
// 添加一个元素
strList = append(strList, "quanxiaoha")
// 添加多个元素
strList = append(strList, "www", "quanxiaoha", "com")
// 添加切片
list := []string{"犬小哈", "教程"}
// list 后面的 ... 表示将 list 整个添加到 strList 切片中
strList = append(strList, list...)
fmt.Println(strList)
}
代码输出如下:
[quanxiaoha www quanxiaoha com 犬小哈 教程]
五、从数组或切片生成新的切片
从数组或切片生成新的切片是很常见的操作，格式如下:
slice [开始位置:结束位置]
slice从数组中生成切片：
package main
import "fmt"
func main() {
var arr = [3]int{1, 2, 3}
fmt.Println(arr, arr[1:2])
}
代码输出如下:
[1 2 3] [2]
arr[1:2]5.1 从指定范围中生成切片
package main
import "fmt"
func main() {
var arr = [20]int{}
// 向数组中添加元素
for i := 0; i < 20; i++ {
arr[i] = i + 1
}
// 指定区间
fmt.Println(arr[8:15])
// 中间到尾部所有元素
fmt.Println(arr[10:])
// 开头到中间所有元素
fmt.Println(arr[:10])
// 切片本身
fmt.Println(arr[:])
}
代码输出:
[9 10 11 12 13 14 15]
[11 12 13 14 15 16 17 18 19 20]
[1 2 3 4 5 6 7 8 9 10]
[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20]
arr[10:]arr[:10]arr[:]5.2 重置切片
若把切片的开始位置和结束位置都设置为 0， 则会生成一个空的切片：
package main
import "fmt"
func main() {
var arr = [20]int{}
// 向数组中添加元素
for i := 0; i < 20; i++ {
arr[i] = i + 1
}
fmt.Println(arr[0:0])
}
代码输出:
[]
六、复制切片元素到另一个切片
copy()copy( destSlice, srcSlice []T) int
srcSlicedestSlice演示代码如下:
package main
import "fmt"
func main() {
// 设置元素数量为 10
const count = 10
// 源分片
srcSlice := make([]int, count)
// 给源分片赋值
for i := 0; i < count; i++ {
srcSlice[i] = i
}
// 目标分片
destSlice := make([]int, count)
// 将 srcSlice 分片的数据复制到 destSlice 中
copy(destSlice, srcSlice)
fmt.Println(srcSlice)
fmt.Println(destSlice)
}
代码输出:
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
另外，我们还可以复制指定范围的数据:
// 将 srcSlice 分片中指定范围的数据复制到 destSlice 中
copy(destSlice, srcSlice[4:8])
fmt.Println(srcSlice)
fmt.Println(destSlice)
代码输出:
[0 1 2 3 4 5 6 7 8 9]
[4 5 6 7 0 0 0 0 0 0]
七、从切片中删除元素
Go 语言中并没有提供特定的函数来删除切片中元素，但是可以利用切片的特性来达到目的：
package main
import "fmt"
func main() {
// 声明一个字符串类型的切片
arr := []string{"q", "u", "a", "n", "x", "i", "a", "o", "h", "a"}
// 指定删除位置，也就是 u 元素
index := 1
// 打印删除位置之前和之后的元素， arr[:index] 表示的是被删除元素的前面部分数据，arr[index+1:] 表示的是被删除元素后面的数据
fmt.Println(arr[:index], arr[index+1:])
// 将删除点前后的元素拼接起来
arr = append(arr[:index], arr[index+1:]...)
fmt.Println(arr)
}
代码输出如下：
[q] [a n x i a o h a]
[q a n x i a o h a]
总结：Go 语言中切片删除元素的本质即： 以被删除元素为分界点, 将前后两个部分的内存重新连接起来。