Title

Go的切片

切片

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。支持自动扩容

切片是一个引用类型

切片内部结构包含地址、长度和容量

var name []T

func main() {
  var a []string               // 声明一个字符串切片
  var b = []int{}              // 声明一个整型切片并初始化
  var c = []bool{true, false}  // 声明一个布尔切片并初始化
  // var d = []bool{true, false}  // 声明一个布尔切片并初始化
  fmt.Println(a)               // []
  fmt.Println(b)               // []
  fmt.Println(c)               // [true, false]
  fmt.Println(a == nil)        // true
  fmt.Println(b == nil)        // false
  fmt.Println(c == nil)        // false
  // fmt.Println(c == d)       // 切片是引用类型，不支持直接比较,只能和nil比较
}

切片的长度和容量

切片拥有自己的长度和容量，使用内置的len()函数求长度，使用内置的cap()函数求容量

基于数组定义切片

func main() {
  a := [5]int{55, 66, 77, 88,  99}
  b := a[1:4]    
  fmt.Println(b)                      // [66, 77, 88]
  fmt.Printf("type of b: %T
", b)    // type of b: []int
  b[0] = 1                            // 切片b修改元素会影响到a
  fmt.Println(a)                      // [55 1 77 88 99]
}

基于切片再切片

func main() {
  a := [...]string{"北京", "上海", "广州", "深圳", "成都", "西安"}
  fmt.Printf("a: %v, type: %T, len: %d, cap: %d
", a, a, len(a), cap(a))
  b := a[1:3]
  fmt.Printf("b: %v, type: %T, len: %d, cap: %d
", b, b, len(b), cap(b))
  c := b[1:5]
  fmt.Printf("c: %v, type: %T, len: %d, cap: %d
", c, c, len(c), cap(c))
}
//a: [北京 上海 广州 深圳 成都 西安], type: [6]string, len: 6, cap: 6
//b: [上海 广州], type: []string, len: 2, cap: 5
//c: [广州 深圳 成都 西安], type: []string, len: 4, cap: 4
// 对b来说,len得到元素的个数，cap得到b的起始到a的末端容量
// 对c来说,len得到的是切片a中的4个元素,cap容量是c的起始到a的末端容量

注意： 对切片(b)进行再切片(c)时，索引不能超过原数组的长度，否则会出现索引越界的错误

使用make()函数构造切片

使用make()函数动态创建切片

make([]T, size, cap)
// T:切片的元素类型
// size:切片中元素的数量
// cap:切片的容量

func main() {
  a := make([]int, 2, 10)
  fmt.Printf("a: %v, len: %d, cap: %d", a, len(a), cap(a))
}
// a: [0 0], len: 2, cap: 10

切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）

func main() {
  a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}
  s1 := a[:5]    // s1 的len=5， cap=8，cap为a的容量,因为切片a的起始值为a的起始值
  s2 := a[3:6]   // s2 的len=3，cap=5，cap的起始值为a中的3到末尾
}

切片不能直接比较

不能使用==操作符来判断两个切片是否含有全部相等元素

切片唯一合法的比较操作是和nil比较

nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0

注意 ：一个长度和容量都是0的切片不一定是nil

var s1 []int         //len(s1)=0; cap(s1)=0; s1==nil
s2 := []int{}        //len(s2)=0; cap(s2)=0; s2!=nil
s3 := make([]int, 0) //len(s3)=0; cap(s3)=0; s3!=nil

判断一个切片是否是空的，要是用len(s) == 0来判断，不应该使用s == nil来判断

切片的赋值拷贝

func main() {
 s1 := make([]int, 5)  // [0, 0, 0, 0, 0]
 s2 := s1[2:]          // 共享底层数组
 s2[0] = 100
 fmt.Println(s1)       // [0 0 100 0 0]
 fmt.Println(s2)       // [100 0 0]
 
}

注意： 对一个切片的修改会影响另一个切片的内容

切片的遍历

切片的遍历和数组的是一致的，可通过索引遍历和for range遍历

func main() {
  s := []int{1, 3, 5}
  for i := 0; i < len(s); i++ {
    fmt.Println(i, s[i])
  }
  for index, value := range s {
    fmt.Println(index, value)
  }
}

append方法为切片添加元素

• 每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素
• 当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行扩容，此时该切片指向的底层数组就会更换
• 扩容操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值

func main() {
  // append()添加元素和切片扩容
  var numSlice []int
  for i := 0; i < 10; i++ {
    numSlice = append(numSlice, i)
    fmt.Printf("%v len:%d, cap:%d, ptr:%p
", numSlice, len(numSlice), cap(numSlice), numSlice)
  }
}
// [0] len:1, cap:1, ptr:0xc000016080
// [0 1] len:2, cap:2, ptr:0xc0000160c0
// [0 1 2] len:3, cap:4, ptr:0xc000018180
// [0 1 2 3] len:4, cap:4, ptr:0xc000018180
// [0 1 2 3 4] len:5, cap:8, ptr:0xc000012080
// [0 1 2 3 4 5] len:6, cap:8, ptr:0xc000012080
// [0 1 2 3 4 5 6] len:7, cap:8, ptr:0xc000012080
// [0 1 2 3 4 5 6 7] len:8, cap:8, ptr:0xc000012080
// [0 1 2 3 4 5 6 7 8] len:9, cap:16, ptr:0xc000078000
// [0 1 2 3 4 5 6 7 8 9] len:10, cap:16, ptr:0xc000078000

肉眼可见：切片numSlice的容量按照1，2，4，8，16这样的规则自动进行扩容，每次扩容后都是扩容前的2倍

append()函数还支持一次性追加多个元素

func main() {
  var citySlice []string
  citySlice = append(citySlice, "北京")
  citySlice = append(citySlice, "上海", "广州", "深圳")
  a := []string{"成都", "重庆"}
  citySlice = append(citySlice, a...)
  fmt.Println(citySlice)
}
// [北京 上海 广州 深圳 成都 重庆]

切片扩容策略

通过查看$GOROOT/src/runtime/slice.go源码，其中扩容相关代码如下

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

• 首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
• 否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
• 否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
• 如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap)

使用copy()函数复制切片

首先： 记住切片是引用类型

Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中

func main() {
  // copy()复制切片
  a := []int{1, 2, 3, 4, 5}
  b := make([]int, 5, 5)
  copy(b, a)   // 将切片a中的元素复制到切片b
  fmt.Println(a)
  fmt.Println(b)
  b[0] = 100
  fmt.Println(a)
  fmt.Println(b)
}
// [1 2 3 4 5]
// [1 2 3 4 5]
// [1 2 3 4 5]
// [100 2 3 4 5]

go删除切片元素

go中没有明确的删除元素的专用方法，只能通过索引来操作

func main() {
  a := []int{0，1, 2, 3, 4, 5, 6, 7, 8, 9}
  // 删除索引为2到4的元素
  a = append(a[:2], a[5:]...)
  fmt.Println(a)
}
// [0 1 5 6 7 8 9]

要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)

func main() {
	a := make([]int, 5, 10)
	fmt.Println(a)
	for i := 0; i < 10; i++ {
		a = append(a, i)
		fmt.Println(a)
	}
}
// [0 0 0 0 0]
// [0 0 0 0 0 0]
// [0 0 0 0 0 0 1]
// [0 0 0 0 0 0 1 2]
// [0 0 0 0 0 0 1 2 3]
// [0 0 0 0 0 0 1 2 3 4]
// [0 0 0 0 0 0 1 2 3 4 5]
// [0 0 0 0 0 0 1 2 3 4 5 6]
// [0 0 0 0 0 0 1 2 3 4 5 6 7]
// [0 0 0 0 0 0 1 2 3 4 5 6 7 8]
// [0 0 0 0 0 0 1 2 3 4 5 6 7 8 9]