• 在go语言中，数组的长度不可改变，在某些场景中不适用。便提供了一种灵活的动态数组，即切片。
  • 切片的长度是不固定的，可以追加元素，可使容量变大
  • 无需设定长度
  1. func main() {
  3.     //定义切片,和数组很像，不指定长度即为切片
  4.     var arr1=[4] int{1,2,3,4} //数组
  5.     var arr=[] int{1,2,3,4,5,6}   //切片
  6.     fmt.Println(arr1,arr)
  8. }

1.make（）创建切片

  1. func main() {   
  2.     //创建格式：make([]type,len,cap)
  3.     arr:=make([]int,5,10) //长度为5 容量为10
  4.     fmt.Println(len(arr),cap(arr))  
  5. }

2.追加元素与切片扩容

  1. func main() {   
  2.     //元素追加
  3.     arr:=make([]int,0,6) 
  4.     fmt.Println(len(arr),cap(arr))  //长度为0，容量6
  5.     arr=append(arr,1,2,3,4,5 )  //追加了5个元素
  6.     fmt.Println(len(arr),cap(arr))   //长度为5，容量6
  8.     //切片扩容
  9.     arr=append(arr,1,2,3,4,5,7,8,9 ) //追加后自动扩容
  10.     fmt.Println(len(arr),cap(arr))   // 长度为5，容量14
  12.     //将切片引入至另一个切片
  13.     fmt.Println(arr)
  14.     arr1:=[]int{100,200,300} //[1 2 3 4 5 1 2 3 4 5 7 8 9]
  15.     arr=append(arr,arr1... ) //将arr1中的元素追加到arr中
  16.     fmt.Println(arr) //[1 2 3 4 5 1 2 3 4 5 7 8 9 100 200 300]
  17. }

3.切片遍历

  1. for i := 0; i < len(arr); i++ {
  2.         fmt.Println(arr[i])
  3.     }
  5.     for i, v := range arr {
  6.         fmt.Println(i,v)
  7.     }

4.切片底层复制扩容逻辑

  1. func main() {   
  2.     arr :=[]int{1,3,4}
  3.     arr1 :=make([]int,len(arr),cap(arr)*2) 
  4.     copy(arr1,arr) //将arr元素复制给arr1
  5.     fmt.Printf("%d,%d,%v\n",len(arr1),cap(arr1),arr)//3,6,[1 3 4]
  7. }

5.深拷贝与浅拷贝

深拷贝：拷贝是数据的本身

浅拷贝：拷贝的是数据地址，多个变量同时指向一个地址