一、 为什么要使用切片

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。 它非常灵活，支持自动扩容。
切片是一个引用类型，它的内部结构包含地址、长度和容量。
声明切片类型的基本语法如下：

  1. var name [] T

其中：

  • name：表示变量名
  • T：表示切片中的元素类型

举例

  1. // 声明切片，把长度去除就是切片
  2. var slice = []int{1,2,3}
  3. fmt.Println(slice)

二、 关于nil的认识

当你声明了一个变量，但却还并没有赋值时，golang中会自动给你的变量赋值一个默认的零值。这是每种类型对应的零值。
nil表示空，也就是数组初始化的默认值就是nil

bool false
numbers 0
string “”
pointers nil
slices nil
maps nil
channels nil
functions nil 
  1. var slice2 [] int
  2. fmt.Println(slice2 == nil)

运行结果

  1. true

三、 切片的遍历

切片的遍历和数组是一样的

  1. var slice = []int{1,2,3}
  2. for i := 0; i < len(slice); i++ {
  3.     fmt.Print(slice[i], " ")
  4. }
  5. //for range遍历
  6. for index, value := range s {
  7.         fmt.Println(index, value)
  8.     }

四、 基于数组定义切片

由于切片的底层就是一个数组，所以我们可以基于数组来定义切片

  1. // 基于数组定义切片
  2. a := [5]int {55,56,57,58,59}
  3. // 获取数组所有值，返回的是一个切片
  4. b := a[:]
  5. // 从数组获取指定的切片
  6. c := a[1:4]
  7. // 获取 下标3之前的数据（不包括3）
  8. d := a[:3]
  9. // 获取下标3以后的数据（包括3）
  10. e := a[3:]

运行结果

  1. [55 56 57 58 59]
  2. [55 56 57 58 59]
  3. [56 57 58]
  4. [55 56 57]
  5. [58 59]

同理，我们不仅可以对数组进行切片，还可以切片在切片

五、 切片的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。
切片的长度就是它所包含的元素个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。切片s的长度和容量可通过表达式len(s)和cap(s)来获取。
举例

  1. // 长度和容量
  2. s := []int {2,3,5,7,11,13}
  3. fmt.Printf("长度%d 容量%d\n", len(s), cap(s))
  4. ss := s[2:]
  5. fmt.Printf("长度%d 容量%d\n", len(ss), cap(ss))
  6. sss := s[2:4]
  7. fmt.Printf("长度%d 容量%d\n", len(sss), cap(sss))

运行结果

  1. 长度6 容量6
  2. 长度4 容量4
  3. 长度2 容量4

为什么最后一个容量不一样呢，因为我们知道，经过切片后sss = [5, 7] 所以切片的长度为2，但是一因为容量是从2的位置一直到末尾，所以为4

六、切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息

  • 底层数组的指针
  • 切片的长度(len)
  • 切片的容量(cap)

举个例子，现在有一个数组 a := [8]int {0,1,2,3,4,5,6,7}，切片 s1 := a[:5]，相应示意图如下
Go语言切片 - 图1
切片 s2 := a[3:6]，相应示意图如下：
Go语言切片 - 图2

七. 使用make函数构造切片

我们上面都是基于数组来创建切片的，如果需要动态的创建一个切片，我们就需要使用内置的make函数，格式如下：

  1. make ([]T, size, cap)

其中：

  • T：切片的元素类型
  • size：切片中元素的数量
  • cap：切片的容量

举例：

  1. // make()函数创建切片
  2. fmt.Println()
  3. var slices = make([]int, 4, 8)
  4. //[0 0 0 0]
  5. fmt.Println(slices)
  6. // 长度：4, 容量8
  7. fmt.Printf("长度：%d, 容量%d", len(slices), cap(slices))

扩容

需要注意的是，golang中没办法通过下标来给切片扩容，如果需要扩容，需要用到append

  1. slices2 := []int{1,2,3,4}
  2. slices2 = append(slices2, 5)
  3. fmt.Println(slices2)
  4. // 输出结果 [1 2 3 4 5]

不用初始化也可以

  1. var s []int
  2. s = append(s, 1, 2, 3)

合并

同时切片还可以将两个切片进行合并

  1. // 合并切片
  2. slices3 := []int{6,7,8}
  3. slices2 = append(slices2, slices3...)
  4. fmt.Println(slices2)
  5. // 输出结果  [1 2 3 4 5 6 7 8]

需要注意的是，切片会有一个扩容操作，当元素存放不下的时候，会将原来的容量扩大两倍

八 . 使用copy()函数复制切片

前面我们知道，切片就是引用数据类型

  • 值类型：改变变量副本的时候，不会改变变量本身
  • 引用类型：改变变量副本值的时候，会改变变量本身的值

如果我们需要改变切片的值，同时又不想影响到原来的切片，那么就需要用到copy函数

  1. // 需要复制的切片
  2. var slices4 = []int{1,2,3,4}
  3. // 使用make函数创建一个切片
  4. var slices5 = make([]int, len(slices4), len(slices4))
  5. // 拷贝切片的值
  6. copy(slices5, slices4)
  7. // 修改切片
  8. slices5[0] = 4
  9. fmt.Println(slices4)
  10. fmt.Println(slices5)

运行结果为

  1. [1 2 3 4]
  2. [4 2 3 4]

九 . 删除切片中的值

Go语言中并没有删除切片元素的专用方法，我们可以利用切片本身的特性来删除元素。代码如下

  1. // 删除切片中的值
  2. var slices6 = []int {0,1,2,3,4,5,6,7,8,9}
  3. // 删除下标为1的值
  4. slices6 = append(slices6[:1], slices6[2:]...)
  5. fmt.Println(slices6)

运行结果

  1. [0 2 3 4 5 6 7 8 9]

十 . 切片的排序算法以及sort包

编写一个简单的冒泡排序算法

  1. func main() {
  2.     var numSlice = []int{9,8,7,6,5,4}
  3.     for i := 0; i < len(numSlice); i++ {
  4.         flag := false
  5.         for j := 0; j < len(numSlice) - i - 1; j++ {
  6.             if numSlice[j] > numSlice[j+1] {
  7.                 var temp = numSlice[j+1]
  8.                 numSlice[j+1] = numSlice[j]
  9.                 numSlice[j] = temp
  10.                 flag = true
  11.             }
  12.         }
  13.         if !flag {
  14.             break
  15.         }
  16.     }
  17.     fmt.Println(numSlice)
  18. }

在来一个选择排序

  1. // 编写选择排序
  2. var numSlice2 = []int{9,8,7,6,5,4}
  3. for i := 0; i < len(numSlice2); i++ {
  4.     for j := i + 1; j < len(numSlice2); j++ {
  5.         if numSlice2[i] > numSlice2[j] {
  6.             var temp = numSlice2[i]
  7.             numSlice2[i] = numSlice2[j]
  8.             numSlice2[j] = temp
  9.         }
  10.     }
  11. }
  12. fmt.Println(numSlice2)

对于int、float64 和 string数组或是切片的排序，go分别提供了sort.Ints()、sort.Float64s() 和 sort.Strings()函数，默认都是从小到大进行排序

  1. var numSlice2 = []int{9,8,7,6,5,4}
  2. sort.Ints(numSlice2)
  3. fmt.Println(numSlice2)

10.1 降序排列

Golang的sort包可以使用sort.Reverse(slic e)来调换slice.Interface.Less，也就是比较函数，所以int、float64 和 string的逆序排序函数可以这样写

  1. // 逆序排列
  2. var numSlice4 = []int{9,8,4,5,1,7}
  3. sort.Sort(sort.Reverse(sort.IntSlice(numSlice4)))
  4. fmt.Println(numSlice4)