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 main

import "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，3
	arr2 := [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 main

import "fmt"

func main(){
	var arr1[2][2]int
	var arr2[2][2]int

	for i,_ := range arr2{
		for j, _ := range arr2[i]{
			arr2[i][j] = i + 1
		}
	}

	arr1 = arr2
	arr2[0][1] = 10
	arr2[1][1] = 20
	for 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 main
  
  import "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 main
  
  import "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，容量为20
  	slice2 := 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 main
  
  import "fmt"
  
  func main() {
  	var slice1 []int
  	for 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 main
  
  import "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的所有元素复制到slice1
  	cp2 := 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 main

import "fmt"

func main() {
	var slice1 [][]int
	slice1 = [][]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值的切片并没有底层数组
• 数组传递给函数的时候，是需要先拷贝再传递；而切片是引用传递，函数内可以直接修改切片的内容