一、切片(Slice)

1.1 什么是切片

• Go语言切片是对数组的抽象.
• Go数组的长度不可改变,在特定场景中这样的集合就不太适用,Go中提供了一种灵活,功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的,可以追加元素,在追加时可能使切片的容量增大
• 切片是一种方便、灵活且强大的包装器.切片本身没有任何数据.它们只是对现有数组的引用.
• 切片与数组相比,不需要设定长度,在[]中不用设定值,相对来说比较自由

从概念上面来说slice像一个结构体,这个结构体包含了三个元素:

• 1.指针,指向数组中slice指定的开始位置
• 2.长度,即slice的长度
• 3.最大长度,也就是slice开始位置到数组的最后位置的长度

1.2 切片的语法

定义切片

var identifier []type

切片不需要说明长度.或使用make()函数来创建切片

var slice1 []type = make([]type, len)

# 也可以简写为
slice1 := make([]type, len)

make([]T, length, capacity)

初始化

s[0] = 1
s[1] = 2
s[2] = 3

s :=[] int {1,2,3 } 

s := arr[startIndex:endIndex] 

将arr中从下标startIndex到endIndex-1下的元素创建为一个新的切片(前闭后开),长度为endIndex-startIndex

s := arr[startIndex:] 

缺省endIndex时将表示一直到arr的最后一个元素

s := arr[:endIndex] 

缺省startIndex时将表示从arr的第一个元素开始

package main

import (  
    "fmt"
)

func main() {  
    a := [5]int{76, 77, 78, 79, 80}
    var b []int = a[1:4] //creates a slice from a[1] to a[3]
    fmt.Println(b)
}

1.3 修改切片

• slice没有自己的任何数据.它只是底层数组的一个表示.对slice所做的任何修改都将反映在底层数组中.

package main

import (  
    "fmt"
)

func main() {  
    darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
    dslice := darr[2:5]
    fmt.Println("array before",darr)
    for i := range dslice {
        dslice[i]++
    }
    fmt.Println("array after",darr) 
}

运行结果:

array before [57 89 90 82 100 78 67 69 59]  
array after [57 89 91 83 101 78 67 69 59]  

当多个片共享相同的底层数组时,每个元素所做的更改将在数组中反映出来.

package main

import (  
    "fmt"
)

func main() {  
    numa := [3]int{78, 79 ,80}
    nums1 := numa[:] //creates a slice which contains all elements of the array
    nums2 := numa[:]
    fmt.Println("array before change 1",numa)
    nums1[0] = 100
    fmt.Println("array after modification to slice nums1", numa)
    nums2[1] = 101
    fmt.Println("array after modification to slice nums2", numa)
}

运行结果:

array before change 1 [78 79 80]  
array after modification to slice nums1 [100 79 80]  
array after modification to slice nums2 [100 101 80]  

1.4 len() 和 cap() 函数

• 切片的长度是切片中元素的数量.切片的容量是从创建切片的索引开始的底层数组中元素的数量.
• 切片是可索引的,并且可以由len()方法获取长度
• 切片提供了计算容量的方法cap()可以测量切片最长可以达到多少

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=3 cap=5 slice=[0 0 0]

空切片

• 一个切片在未初始化之前默认为nil,长度为0

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=0 cap=0 slice=[]
切片是空的

package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

1.5 append() 和 copy() 函数

• append向slice里面追加一个或者多个元素,然后返回一个和slice一样类型的slice
• copy函数copy从源slice的src中复制元素到目标dst,并且返回复制的元素的个数

append函数会改变slice所引用的数组的内容,从而影响到引用同一数组的其它slice. 但当slice中没有剩 余空间(即(cap-len) == 0)时,此时将动态分配新的数组空间.返回的slice数组指针将指向这个空间,而原 数组的内容将保持不变;其它引用此数组的slice则不受影响

下面的代码描述了从拷贝切片的copy方法和向切片追加新元素的append方法

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

运行结果

len=0 cap=0 slice=[]
len=1 cap=2 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=8 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]

numbers1与numbers两者不存在联系,numbers发生变化时,numbers1是不会随着变化的.也就是说copy方法是不会建立两个切片的联系的

1.6.综合示例代码

package main

import "fmt"

func main() {
	/*
		数组array:
			存储一组相同数据类型的数据结构.
				特点: 定长
		切片slice:
			同数组类似,也叫变长数组或者动态数组.
				特点: 变长

			是一个引用类型的容器,指向了一个底层数组.

		make()
			func make(t Type,size ...IntegerType) Type

			第一个参数: 类型
				slice,map,chan
			第二个参数: 长度len
				实际存储元素的数量
			第三个参数: 容量cap
				最多能存储的元素的数量

		append(),专门用于向切片的尾部追加元素
			slice = append(slice, elem1, elem2)
			slice = append(slice, anotherSlice...)

	*/
	//1.数组
	arr := [4]int{1, 2, 3, 4}
	fmt.Println(arr)

	//2.切片
	var s1 []int
	fmt.Println(s1)

	s2 := []int{1, 2, 3, 4} //变长
	fmt.Println(s2)
	fmt.Printf("%T,%T\n", arr, s2)

	s3 := make([]int, 3, 8)
	fmt.Println(s3)
	fmt.Printf("容量: %d,长度: %d\n", cap(s3), len(s3))
	s3[0] = 1
	s3[1] = 2
	s3[2] = 3
	fmt.Println(s3)
	//fmt.Println(s3[3])	// panic: runtime error: index out of range [3] with length 3

	// append()
	s4 := make([]int, 0, 5)
	fmt.Println(s4)
	s4 = append(s4, 1, 2)
	fmt.Println(s4)
	s4 = append(s4, 3, 4, 5, 6, 7)
	fmt.Println(s4)
	s4 = append(s4, s3...)
	fmt.Println(s4)

	//遍历切片
	for i := 0; i < len(s4); i++ {
		fmt.Println(s4[i])
	}

	for i, v := range s4 {
		fmt.Printf("%d--->%d\n", i, v)
	}
}

二、Slice的内存分析以及扩容

slice的容量(cap)扩容与slice初始容量(cap)是倍数关系例如

​ 4 ---> 8 ---> 16 ---> 32

package main

import "fmt"

func main() {
	/*
		切片Slice:
			1.每一个切片引用了一个底层数组
			2.切片本身存储任何数据,都是这个底层数组存储,所以修改切片也就是修改这个数组中的数据
			3.当向切片中添加数据时,如果没有超过容量,直接添加,如果超过容量,自动扩容(成倍增长)
			4.切片一旦扩容,就是重新指向一个新的底层数组
	*/
	s1 := []int{1, 2, 3}
	fmt.Println(s1)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1) //引用类型的数据的话,"%p"按照地址的格式去打印  0xc0000ae078

	s1 = append(s1, 4, 5)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1) // 0xc0000cc030

	s1 = append(s1, 6, 7, 8)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 9, 10)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1)

	s1 = append(s1, 11, 12, 13, 14, 15)
	fmt.Printf("len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("%p\n", s1)

}

三、在已有数组上直接创建Slice

package main

import "fmt"

func main() {
	/*
		slice := arr[start:end]
			切片中的数据: [start:end]
			arr[:end],从头到end
			arr[start:]从start到末尾

		从已有的数组上,直接创建切片,该切片的底层数组就是当前的数组.
			长度从start到end切片的数据量.
			但是容量从start到数组的末尾.
	*/
	a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("---------1.已有数组直接创建切片----------")
	s1 := a[:5]  //1-5
	s2 := a[3:8] //3-8
	s3 := a[5:]
	s4 := a[:]
	fmt.Println("a:", a)
	fmt.Println("s1:", s1)
	fmt.Println("s2:", s2)
	fmt.Println("s3:", s3)
	fmt.Println("s4:", s4)

	fmt.Printf("%p\n", &a)
	fmt.Printf("%p\n", s1)
	fmt.Printf("%p\n", s2)
	fmt.Printf("%p\n", s3)
	fmt.Printf("%p\n", s4)

	fmt.Println("---------2.长度和容量----------")
	fmt.Printf("s1  len:%d,cap:%d\n", len(s1), cap(s1))
	fmt.Printf("s1  len:%d,cap:%d\n", len(s2), cap(s2))
	fmt.Printf("s1  len:%d,cap:%d\n", len(s3), cap(s3))
	fmt.Printf("s1  len:%d,cap:%d\n", len(s4), cap(s4))

	fmt.Println("---------3.更改数组的内容----------")
	a[4] = 100
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)

	fmt.Println("---------3.更改切片的内容----------")
	// 操作s2切片也是同时操作a数组
	s2[2] = 200
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)

	fmt.Println("---------4.更改切片的内容----------")
	s1 = append(s1, 1, 1, 1, 1) // 切片s1添加元素,底层数组a中的数据会发生变化
	fmt.Println(a)
	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)

	fmt.Println("---------5.添加元素切片扩容----------")
	fmt.Println(len(s1), cap(s1))

	s1 = append(s1, 2, 2, 2, 2, 2)
	fmt.Println(a)  // 底层数组a没有发生变化
	fmt.Println(s1) // 切片s1自动扩容了
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println(len(s1), cap(s1))
	fmt.Printf("%p\n", s1)
	fmt.Printf("%p\n", &a)
}

四、切片是引用类型

示例代码

package main

import "fmt"

func main() {
	/*
		按照数据类型来分:
			基本类型: int、float、string、bool
			复合类型: array、slice、map、struct、pointer、function、chan

		按照该特点来分:
			值类型: init、float、string、bool、array
			引用类型: Slice
				传递的地址,多个变量指向了同一块内存地址.

		所以: 切片是引用类型的数据,存储了底层数组的引用
	*/

	//1.数组: 值类型
	a1 := [4]int{1, 2, 3, 4}
	a2 := a1 // 值传递,传递的是数据
	fmt.Println(a1, a2)
	a1[0] = 100
	fmt.Println(a1, a2)

	//2.切片: 引用类型
	s1 := []int{1, 2, 3, 4}
	s2 := s1
	fmt.Println(s1, s2)
	s1[0] = 100
	fmt.Println(s1, s2)

	fmt.Printf("%p\n", s1)  //获取的是底层数组的存储地址
	fmt.Printf("%p\n", s2)  //获取的是底层数组的存储地址
	fmt.Printf("%p\n", &s1) //获取的是s1本身切片的地址
	fmt.Printf("%p\n", &s2) //获取的是s2本身切片的地址
}

五、深拷贝和浅拷贝

• 深拷贝: 拷贝的是数据本身

  • 值类型的数据,默认都是深拷贝: array、int、float、string、bool、struct

• 浅拷贝: 拷贝的是数据地址

  • 导致多个变量指向同一块内存
  • 引用类型的数据,默认都是浅拷贝: slice、map
  • 因为切片是引用类型的数据,直接拷贝的是地址.

示例代码

package main

import "fmt"

func main() {
	/*
		深拷贝: 拷贝的是数据本身
		  值类型的数据,默认都是深拷贝: array、int、float、string、bool、struct

		浅拷贝: 拷贝的是数据地址
		  导致多个变量指向同一块内存
		  引用类型的数据,默认都是浅拷贝: slice、map
		  因为切片是引用类型的数据,直接拷贝的是地址.

		func copy(dst, src []Type) int
			可以实现切片的拷贝
	*/
	s1 := []int{1, 2, 3, 4}
	s2 := make([]int, 0) //len:0,cap:0
	for i := 0; i < len(s1); i++ {
		s2 = append(s2, s1[i])
	}
	fmt.Println(s1)
	fmt.Println(s2)

	s1[0] = 100
	fmt.Println(s1)
	fmt.Println(s2)

	//copy(),提供给Slice进行深拷贝的
	s3 := []int{7, 8, 9}
	fmt.Println(s2)
	fmt.Println(s3)

	copy(s2, s3) //func copy(dst, src []Type) int,将s3中的元素拷贝到s2中
	copy(s3[1:], s2[2:])
	fmt.Println(s2)
	fmt.Println(s3)
}