Go语言中数组、字符串和切片三者是密切相关的数据结构。这3种数据类型，在底层原始数据有着相同的内存结构，在上层，因为语法的限制而有着不同的行为表现。

数组

Go 语言里，数组是一个长度固定的数据类型，用于存储一段具有相同的类型的元素的连续块。数组存储的类型可以是内置类型，如整型或者字符串，也可以是某种结构类型。

数组是一种非常有用的数据结构，因为其占用的内存是连续分配的。

  1. // 声明一个长度为5的int型数组arrary
  2. var array [5]int
  3. // 声明数组并初始化
  4. array2 := [5]int{10, 20, 30, 40, 50}

如果使用…替代数组的长度，Go 语言会自动计算长度

  1. array := [...]int{10, 20, 30, 40, 50}

使用数组

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // 定义数组
  7.     var arr [3]int
  8.     // 可以设置初始值
  9.     var arr2 = [...]int{1, 2, 3}
  10.     // 指定索引初始化
  11.     // 索引:初始值
  12.     // [0,6,7]
  13.     // 长度为最大索引下标元素为主,没有明确初始化的则为零值
  15.     var arr3 = [...]int{1: 6, 2: 7}
  17.     arr[0] = 1
  18.     arr[0] = 0
  19.     arr[0] = 1
  21.     fmt.Println(arr)
  22.     fmt.Println(arr2)
  23.     fmt.Println(arr3)
  25.     // 指针指向数组
  26.     var p = &arr
  28.     fmt.Println(p[0])
  30.     // 指针迭代数组元素
  31.     // index,value
  32.     for i, v := range p {
  33.         fmt.Println(i, v)
  34.     }
  36.     // 二维数组
  37.     boxes := [2][2]int{{1, 0}, {0, 1}}
  38.     // 访问二维数组
  40.     fmt.Println(boxes[1][1])
  42. }
  1. package main
  3. import (
  4.     "fmt"
  5. )
  11. func main() {
  13.     // 固定长度数组 初始值默认为 0
  14.     var arr [5]int
  15.     // 初始化固定长度数组
  16.     // 仅可通过简短变量初始化数组内容
  17.     arr2:=[3]int{1,2,3}
  19.     // 自动推断数组长度
  20.     arr3:=[...]int{1,1,0,0}
  22.     // len(数组名称) 来获得数组长度
  23.     fmt.Println(len(arr),len(arr2),len(arr3))
  24.     // 查看数组类型
  25.     fmt.Printf("%T\n",arr)
  26.     fmt.Printf("%T\n",arr2)
  27.     fmt.Printf("%T\n",arr3)
  31.     // 遍历数组
  32.     for i:=0;i<len(arr2);i++{
  33.         fmt.Println(arr2[i])
  34.     }
  36.     for i,v:=range arr3{
  37.         fmt.Println("index=",i,"value=",v)
  38.     }
  40. }
  1. 5 3 4
  2. [5]int
  3. [3]int
  4. [4]int
  5. 1
  6. 2
  7. 3
  8. index= 0 value= 1
  9. index= 1 value= 1
  10. index= 2 value= 0
  11. index= 3 value= 0
  • 需要注意的是数组作为函数参数传递时是按照值传递进行的

字符串

Go语言字符串底层数据也是对应的字节数组，但是字符串的只读属性禁止了在程序中对底层字节数组的元素的修改。字符串赋值只是复制了数据地址和对应的长度，而不会导致底层数据的复制。

切片

切片的行为更为灵活，切片的结构和字符串结构类似，但是解除了只读限制。切片的底层数据虽然也是对应数据类型的数组，但是每个切片还有独立的长度和容量信息，切片赋值和函数传参时也是将切片头信息部分按传值方式处理。

  1. package main
  3. import "fmt"
  5. func printSlice(arr []int,title string)  {
  6.     fmt.Println("========",title,"========")
  7.     fmt.Println("Length:",len(arr))
  8.     for i,v:=range  arr{
  9.         fmt.Println("index=",i,"value=",v)
  10.     }
  11. }
  13. func test(s []int)  {
  14.     s[0]=-1
  15. }
  17. func main() {
  18.     // 定义一个slice
  19.     slice :=[]int{1,1,2,3,4}
  20.     fmt.Printf("%T\n",slice)
  21.     test(slice)
  22.     printSlice(slice,"slice1")
  23. }
  1. []int
  2. ======== slice1 ========
  3. Length: 5
  4. index= 0 value= -1
  5. index= 1 value= 1
  6. index= 2 value= 2
  7. index= 3 value= 3
  8. index= 4 value= 4
  • 需要注意的是数组作为函数参数传递时是按照引用传递进行的

切片操作

  • append 添加元素
  • copy 拷贝切片

声明切片

  1. package main
  3. import "fmt"
  5. func main() {
  6.     // 声明并初始化 slice
  7.     s:= []int{1,2,3}
  8.     fmt.Printf("len=%d,coll=%v\n",len(s),s)
  9.     // 声明一个slice
  10.     var slice []int
  11.     fmt.Printf("len=%d,coll=%v\n",len(slice),slice)
  12.     // 开辟空间
  13.     slice = make([]int,3,5)
  14.     slice[0]=100
  15.     fmt.Printf("len=%d,coll=%v\n",len(slice),slice)
  18.     slice2 :=make([]int,2)
  19.     fmt.Printf("len=%d,coll=%v\n",len(slice2),slice2)
  21.     // 判断slice是否是空的两种方法
  22.     if slice ==nil{
  23.         fmt.Println("slice empty")
  24.     }
  26.     if len(slice2)==0 {
  27.         fmt.Println("slice2 empty")
  28.     }
  29. }

操作切片

  1. package main
  3. import "fmt"
  5. func main() {
  6.     slice :=make([]int,3,5)
  7.     fmt.Printf("len=%d,cap=%d,coll=%v\n",len(slice),cap(slice),slice)
  8.     // 添加元素
  9.     slice = append(slice, 1)
  10.     slice = append(slice, 2)
  11.     slice = append(slice, 3)
  12.     slice = append(slice, 4)
  13.     slice = append(slice, 5)
  15.     fmt.Printf("len=%d,cap=%d,coll=%v\n",len(slice),cap(slice),slice)
  17. }
  1. len=3,cap=5,coll=[0 0 0]
  2. len=8,cap=10,coll=[0 0 0 1 2 3 4 5]

2. 数组,字符串,切片 - 图1

切片截取

  • [start,end) 左闭右开
  • [:4] 从头开始
  • [2:] 截取到尾
  • [:] 截取全部
  1. package main
  3. import "fmt"
  7. func main() {
  8.     slice:= []int{1,2,3,4,5,6,7,8,9,10}
  9.     // 切片截取 左闭右开
  10.     // [,)
  11.     fmt.Printf("%v\n",slice[1:4])
  13.     // copy 拷贝指定部分
  14.     target :=make([]int,3)
  15.     copy(target,slice)
  16.     fmt.Printf("%v\n",target)
  18.     // 将一个切片附加到另一个切片里 可以使用切片展开
  19.     var target2 []int
  20.     // xxxx... 展开切片
  21.     target2 =append(target2,slice...)
  22.     fmt.Printf("%v\n",target2)
  24. }
  1. [2 3 4]
  2. [1 2 3]
  3. [1 2 3 4 5 6 7 8 9 10]