Go语言切片

一、切片

• 切片的英文名称slice
• 切片:具有可变长度相同类型元素序列.
• 由于长度是可变,可以解决数组长度在数据个数不确定情况下浪费内存的问题.
• 切片和数组声明时语法最主要的区别就是长度

var slice []string  //切片
var array [3]string //数组

切片只声明时为nil,没有开辟内存空间,不能直接操作切片,需要先初始化

• 注意:切片只能和nil进行判断是否相等

var slice []string  //切片
fmt.Println(slice==nil)//输出:true
fmt.Printf("%p",slice)//输出:0x0

二、定义切片

通过直接指定初始值定初始化一个切片变量

names := []string{"smallming", "小明"}
fmt.Println(names)

定义完切片后就可以通过切片对象[脚标]取出或修改切片中元素内容.语法和数组相同

三、切片是引用类型

• 引用类型在变量之间赋值时传递的是地址.引用类型变量就是这个类型的指针.切片就是引用类型
• 值类型在变量之间赋值时传递的是值的副本

names := []string{"xiaoming", "小明"}
names1 := names
names1[0] = "王"
fmt.Println(names, names1)//输出:[王 小明 [王 小明]
fmt.Printf("%p %p",names,names1)//地址相同

四、make函数

• Go语言中可以使用make函数创建slice 、 map、 channel、 interface
• 使用make函数定义无内容,但是不是nil的切片,意味着切片已经申请了内存空间
  • make(类型,初始长度[,初始容量])
  • 初始容量可以省略,默认和长度相等

slice := make([]string, 0)     //长度为0的切片,没有第三个参数表示容量和长度相等
slice1 := make([]string, 0, 2) //长度为0,容量为2
fmt.Println(slice, slice1)

长度表示切片中元素的实际个数,容量表示切片占用空间大小,且切片容量成倍增加.当增加到1024后按照一定百分比增加.

• len(slice) 查看切片的长度
• cap(slice) 查看切片的容量

slice := make([]string, 0)     //长度为0的切片,没有第三个参数表示容量和长度相等
slice1 := make([]string, 0, 3) //长度为0,容量为2
fmt.Println(len(slice), cap(slice))
fmt.Println(len(slice1), cap(slice1))

五、append()函数

append()在Go语言标准库中源码如下

// The append built-in function appends elements to the end of a slice. If
// it has sufficient capacity, the destination is resliced to accommodate the
// new elements. If it does not, a new underlying array will be allocated.
// Append returns the updated slice. It is therefore necessary to store the
// result of append, often in the variable holding the slice itself:
//	slice = append(slice, elem1, elem2)
//	slice = append(slice, anotherSlice...)
// As a special case, it is legal to append a string to a byte slice, like this:
//	slice = append([]byte("hello "), "world"...)
func append(slice []Type, elems ...Type) []Type

可以向切片中添加一个或多个值,添加后必须使用切片接收append()函数返回值

s := make([]string, 0)
fmt.Println(len(s), cap(s))//输出:0 0
s = append(s, "老张", "老李")
fmt.Println(len(s), cap(s))//输出:2 2
s = append(s, "smallming")
fmt.Println(len(s), cap(s))//输出:3 4

如果添加一次添加多个值,且添加后的长度大于扩容一次的大小,容量和长度相等.等到下次添加内容时如果不超出扩容大小,在现在的基础上进行翻倍

s := make([]string, 0)
fmt.Println(len(s), cap(s)) //输出:0 0
s = append(s, "老张", "老李")
fmt.Println(len(s), cap(s)) //输出:2 2
s = append(s, "smallming")
fmt.Println(len(s), cap(s)) //输出:3 4
s = append(s, "4", "5", "6", "7", "8", "9")
fmt.Println(len(s), cap(s)) //输出:9 9
s = append(s,"10")
fmt.Println(len(s), cap(s)) //输出:10 18

也可以把一个切片的内容直接添加到另一个切片中.需要注意语法中有三个点

s := make([]string, 0)
s1 := []string{"smallming", "老李"}
s = append(s, s1...) //注意此处,必须有三个点
fmt.Println(s)

七、通过数组产生切片

定义数组后,取出数组中一个片段,这个片段就是切片类型

names := [3]string{"老张", "老李", "smallming"}
s := names[0:2]     //包前不包后
fmt.Printf("%T", s) //输出:[]string
fmt.Println(s)      //输出:[老张 老李]

切片是指针,指向数组元素地址,修改切片的内容,数组的内容会跟随变化

names := [3]string{"老张", "老李", "smallming"}
s := names[0:2] //包前不包后
fmt.Printf("%p %p",s,&names[0])//输出的地址是相同的
s[0] = "Go语言"
fmt.Println(s)     //输出:[Go语言 老李]
fmt.Println(names) //输出:[Go语言 老李 smallming]

当切片内容在增加时

• 如果增加后切片的长度没有超出数组,修改切片也是在修改数组
• 如果增加后切片的长度超出数组,会重新开辟一块空间放切片的内容
• 通过下面代码也正面了切片中内容存在一块连续空间(和数组一样)

names := [3]string{"老张", "老李", "smallming"}
s := names[0:2] //包前不包后
fmt.Printf("%p %p\n",s,&names[0])
s[0] = "Go语言"
s=append(s,"区块链")
fmt.Println(s)     //输出:[Go语言 老李 区块链]
fmt.Println(names) //输出:[Go语言 老李 区块链]
fmt.Printf("%p %p\n",s,&names[0])//地址相同

s=append(s,"超出了数组长度")
fmt.Println(s)     //输出:[Go语言 老李 区块链 超出了数组长度]
fmt.Println(names) //输出:[Go语言 老李 区块链]
fmt.Printf("%p %p\n",s,&names[0])//切片地址改变

八、删除实现

• Go语言标准库中没有提供删除的函数
• 切片也可以取其中的一段形成子切片,利用这个特性可以实现删除效果

num := []int {0,1,2,3,4,5,6}
//要删除脚标为n的元素
n:= 2
num1 :=num[0:n]
num1= append(num1,num[n+1:]...)
fmt.Println(num1)

九、copy函数

• 通过copy函数可以把一个切片内容复制到另一个切片中
• Go语言标准库源码定义如下
  • 第一个参数是目标切片,接收第二个参数内容
  • 第二个参数是源切片,把内容拷贝到第一个参数中

// The copy built-in function copies elements from a source slice into a
// destination slice. (As a special case, it also will copy bytes from a
// string to a slice of bytes.) The source and destination may overlap. Copy
// returns the number of elements copied, which will be the minimum of
// len(src) and len(dst).
func copy(dst, src []Type) int

拷贝时严格按照脚标进行拷贝.且不会对目标切片进行扩容

代码示例

• 把短切片拷贝到长切片中

s1:=[]int {1,2}
s2:=[]int {3,4,5,6}
copy(s2,s1)
fmt.Println(s1)//输出:[1 2]
fmt.Println(s2)//输出:[1 2 5 6]

代码示例

• 把长切片拷贝到短切片中

s1:=[]int {1,2}
s2:=[]int {3,4,5,6}
copy(s1,s2)
fmt.Println(s1)//输出:[3 4]
fmt.Println(s2)//输出:[3 4 5 6]

代码示例

• 把切片片段拷贝到切片中

s1:=[]int {1,2}
s2:=[]int {3,4,5,6}
copy(s1,s2[1:])
fmt.Println(s1)//输出:[4 5]
fmt.Println(s2)//输出:[3 4 5 6]

十、使用copy完成删除元素

使用copy函数可以保证原切片内容不变

s := []int{1, 2, 3, 4, 5, 6, 7}
n := 2 //要删除元素的索引
newSlice := make([]int, n)
copy(newSlice, s[0:n])
newSlice = append(newSlice, s[n+1:]...)
fmt.Println(s)        //原切片不变
fmt.Println(newSlice) //删除指定元素后的切片