Go语言容器之数组和切片

• Go语言的容器分为值类型和引用数据类型

一、数组

1.数组的声明和初始化

(1) 数组声明的语法

• var 数组变量名 [数组大小]数组类型

• 举例：

  package main
  import "fmt"func main(){//数组的声明var arr[10]int//打印数组长度fmt.Println("arr的长度为", len(arr))//数组的赋值for i, _ := range arr{arr[i] = i+1}fmt.Println("打印数组")//打印数组for j, w := range arr{fmt.Println(j, arr[j], w)}}
  

  结果：
  

• 在数组的定义中，若在数组长度的位置出现了"…"省略号，即var 数组变量名[…]数组类型，则表示数组的长度是根据初始化值的个数来决定的。

  package main
  import (
  "fmt"
  )
  func main(){arr1 := [...]int{}arr2 := [...]int{1,2,3,4,5,6,7,8,9}fmt.Println("打印arr1：")for i, _ := range arr1{fmt.Println(arr1[i])}fmt.Println("打印arr2：")for i, _ := range arr2{fmt.Println(arr2[i])}fmt.Printf("arr1的类型为%T：\n",arr1)fmt.Printf("arr2的类型为%T：\n",arr2)
  }
  

  结果：

(2) 比较两个数组是否相等

package mainimport "fmt"func main(){arr1 := [5]int{1,2,3,4,5}arr2 := [...]int{1,2,3,4,5}arr3 := [5]int{0,1,2,3,4}fmt.Printf("arr1==arr2?的结果%v\n",arr1 == arr2)fmt.Printf("arr1==arr3?的结果%v\n",arr1 == arr3)
}

结果：

2.多维数组

• 多维数组的语法：var 数组变量名[size1][size2]…[sizen]数组类型

(1) 声明二维数组

package main
import "fmt"func main(){var arr1[4][3]int//声明一个多维数组，大小为4，3arr2 := [4][3]int{{0,1,2},{1,2,3},{2,3,4},{3,4,5}}//声明数组并初始化所有元素arr3 := [4][3]int{1:{0,1,2},2:{1,2,3}}//声明并初始化数组中指定索引的元素arr4 := [4][3]int{1:{0:20},2:{2:30}}//声明并初始化数组中指定元素for i,v := range arr1{fmt.Printf("arr1的结果：")fmt.Println(v)fmt.Printf("arr2的结果：")fmt.Println(arr2[i])fmt.Printf("arr3的结果：")fmt.Println(arr3[i])fmt.Printf("arr4的结果：")fmt.Println(arr4[i])}
}

结果：

(2) 数组赋值

package mainimport "fmt"func main(){var arr1[2][2]intvar arr2[2][2]intfor i,_ := range arr2{for j, _ := range arr2[i]{arr2[i][j] = i + 1}}arr1 = arr2arr2[0][1] = 10arr2[1][1] = 20for i,v := range arr1{fmt.Printf("arr1的值为：")fmt.Println(v)fmt.Printf("arr2的值为：")fmt.Println(arr2[i])}
}

结果：

二、切片

1.切片概述

• slice切片就是数组中一段连续的片段的引用。故切片是个引用类型
• 从数组或者切片生成新的切片：slice[开始位置 : 结束位置]
• 从数组或者切片中生成新的切片拥有如下特征：
  （1）取出的元素数量为：结束位置 - 开始位置
  （2）取出的元素不包含结束位置对应的索引（左闭右开）。切片最后一个元素是slice[len(slice)]
  （3）当缺省开始位置时，表示从连续区域开头位置到切片结束位置
  （4）当缺省结束位置时，表示从切片开始位置到连续区域末尾位置
  （5）当开始位置和结束位置都缺省时，表示从连续区域开头位置到连续区域末尾位置，即整个连续区域。即表示原有的切片
  （6）当开始位置和结束位置两者都为0时，即空切片。一般用于切片复位
• 切片举例：

  package mainimport "fmt"func main(){arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}fmt.Println("数组arr的值为",arr)fmt.Println("切片arr[0:1]的值为", arr[0:1])fmt.Println("切片arr[2:8]的值为", arr[2:8])fmt.Println("切片arr[4:9]的值为", arr[4:9])fmt.Println("切片arr[5:10]的值为", arr[5:10])fmt.Println("切片arr[5:10]中元素个数为", len(arr[5:10]))fmt.Println("切片最后一个元素arr[len(arr)]的值为",arr[len(arr[4:9])])fmt.Println("切片arr[2:]的值为",arr[2:])fmt.Println("切片arr[:8]的值为",arr[:8])fmt.Println("切片arr[:]的值为",arr[:])
  }
  

  结果：通过结果可以看见，是左闭右开的。
• 声明新切片的语法：var 切片名[]切片类型

  package mainimport "fmt"func main() {var strSlice []string //声明字符串切片var intSlice []int    //声明整型切片var emptySlice []int{} //声明一个空切片fmt.Println(strSlice, intSlice, emptySlice)fmt.Println("len(strSlice)=", len(strSlice))fmt.Println("len(intSlice)=", len(intSlice))fmt.Println("len(emptySlice)=", len(emptySlice))fmt.Println("strSlice == nil ? =", strSlice == nil)fmt.Println("intSlice == nil ? =", intSlice == nil)fmt.Println("emptySlice == nil ? =", emptySlice == nil)
  }
  

  结果：
  

2.make动态构造切片

• 若需要动态创建一个切片，则可以使用make()内建函数：make([]切片类型,切片大小,切片容量)
• 注意：使用make()函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片结果指向已经分配好的区域。设定开始与结束位置不会发生内存分配操作。

  package main
  import "fmt"func main() {slice1 := make([]int, 2, 20)//slice1切片的大小为2，容量为20slice2 := make([]int, 2)//slice2切片的大小为2//slice1和slice2都是预分配了2个元素的切片，只是slice1内部存储空间已经分配了20个，但实际只用了2个fmt.Println("slice1:",slice1)fmt.Println("slice2:",slice2)fmt.Println("len(slice1):",len(slice1))fmt.Println("len(slice2):",len(slice2))
  }
  

  结果：

3.在切片中添加元素

• 切片的len元素个数并不等于切片的cap容量大小，cap容量扩容是2倍进行扩容的

  package mainimport "fmt"func main() {var slice1 []intfor i:=0; i<20; i++{slice1 = append(slice1, i)fmt.Printf("len:%d, cap:%d, pointer:%p\n", len(slice1), cap(slice1), slice1)}
  }
  

  结果：
  

4.切片复制copy

• copy(目标切片, 原切片)

  package mainimport "fmt"func main() {arr := [10]int{0,1,2,3,4,5,6,7,8,9}slice1 := arr[2:9]slice2 := []int{10,11,12,13}fmt.Println("复制前：")fmt.Println("slice1=",slice1)fmt.Println("slice2=",slice2)cp1 := copy(slice1,slice2)//将slice2的所有元素复制到slice1cp2 := copy(slice2,slice1)//将slice1中前几个元素复制到slice2中fmt.Println("复制后：")fmt.Println("slice1=",slice1)fmt.Println("slice2=",slice2)fmt.Println("cp1复制的总数为:", cp1)fmt.Println("cp2复制的总数为:", cp2)
  }
  

  结果：
  

5.range关键字循环切片

package main
import "fmt"func main() {arr := [10]int{0,1,2,3,4,5,6,7,8,9}slice1 := arr[2:9]for i,v:=range slice1{fmt.Printf("index:%d, value:%d\n", i, v)}
}

结果：

6.多维切片

• 声明方法：var 切片名 [][]…[]切片类型

package mainimport "fmt"func main() {var slice1 [][]intslice1 = [][]int{{0,1},{10,11},{20}}fmt.Println("添加元素前：")for i,v:=range slice1{fmt.Printf("index:%d, value:%d\n", i, v)}slice1[2] = append(slice1[2], 100)//为第三个切片添加值为100的元素fmt.Println("添加元素后：")for i,v:=range slice1{fmt.Printf("index:%d, value:%d\n", i, v)}
}

结果：

三、数组和切片的区别

• 数组是数值类型，切片是引用类型
• 数组的长度是固定的，切片的长度不固定，切片是动态的数组
• 数组只有长度的概念，切片还有容量（cap）的概念
• 切片的底层是数组
• 数组之间可以通过"=="比较，判断两个数组是否有相同元素，但是切片不行，只能和nil进行相等判断
• 一个零值的切片等于nil，一个nil值的切片并没有底层数组
• 数组传递给函数的时候，是需要先拷贝再传递；而切片是引用传递，函数内可以直接修改切片的内容