slice
slice 表示用于相同类型元素的可变长度的序列。
slice有三个属性：指针、长度和容量。
- 指针：slice存储数据的内部结构是数组，指针指向的是数组的地址
- 长度：保存slice中的元素数量
- 容量：slice中可容纳的元素数量，在像slice插入元素时，如果超过容量，会对slice进行扩容
slice的基本操作
1.初始化
// 方式一 通过字面量自己初始化
s := []int{}
months := []string{1: "January", /* ... */, 12: "December"}
var z []int
// 方式二 通过切片语法从数组或slice中生成
a := [10]int{1, 2, 3}
b := a[1: 3]
c := b[1:]
// 注意这种奇怪的方式，可以指定具体某个下标的值
e := []int{1:42, 55, 66, 77, 7:88}
fmt.Println(e) // [0 42 55 66 77 0 0 88]
2.访问和更改
// 访问和数组一致，通过下标访问
a := []int{1, 2, 3}
fmt.Println(a[1]) // 2
// 更改
a[1] = 100
fmt.Println(a[1]) // 100
b := a[:]
b[1] = 101 // b和a指向的底层数据一样的，所以b更改会影响a
fmt.Println(b[1], a[1]) // 101 101
3.增加
// 如果想对slice增加一个元素，使用append函数
a := []int{1, 2, 3}
a = append(a, 4)
fmt.Println(a) // [1 2 3 4]
// 使用len函数获取当前slice中元素数量
// 使用cap函数获取当前slice所能支撑的容颜
for i := 5; i < 15; i++ {
a = append(a, i)
fmt.Printf("len: %d cap: %d
", len(a), cap(a))
}
/*OUTPUT:
[1 2 3 4]
len: 5 cap: 6
len: 6 cap: 6
len: 7 cap: 12
len: 8 cap: 12
len: 9 cap: 12
len: 10 cap: 12
len: 11 cap: 12
len: 12 cap: 12
len: 13 cap: 24
len: 14 cap: 24
*/
append函数会处理当当前slice对象的容量不足时，自动扩容（重新申请一块空间并将原来的元素复制过来）。我无法保证原始的slice和调用append后的结果slice执向同一个底层数组。也无法断定旧slice上对元素的操作会或者不会影响新的slice元素。所以通常我们将append的调用结果再次赋值给传入append函数的slice。
4.删除
// 通过copy实现删除
func remove(slice []int, i int) []int {
copy(slice[i:], slice[i+1:])
return slice[:len(slice)-1]
}
a := []{1, 2, 3}
a = remove(a, 1)
fmt.Println(a) // [1 3]
5.翻转slice
func reverse(s []int) {
for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
s[i], s[j] = s[j], s[i]
}
}
a := []int{1, 2, 3}
reverse(a)
fmt.Println(a) // [3 2 1]
6.比较
slice无法使用==进行比较，只允许和nil进行比较。如果想检查slice是否为空，使用len(s) == 0。
var s []int // len(s) == 0, s == nil
s = nil // len(s) == 0, s == nil
s = []int(nil) // len(s) == 0, s == nil
s = []int{} // len(s) == 0, s != nil
slice的用途
1.实现栈
栈的特点是先进后出
stack = []int{}
// 入栈
stack = append(stack, 1)
// 出栈
top := stack[len(stack)-1]
stack = stack[:len(stack)-1]