Featured image of post golang学习八：切片
Go

golang学习八：切片

切片

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

	var slice []string  //切片
	var array [3]string //数组
  • 切片只声明时为nil,没有开辟内存空间,不能直接操作切片,需要先初始化
    • 注意:切片只能和nil进行判断是否相等
1
2
3

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

定义切片

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

	names := []string{"hello", "world"}
	fmt.Println(names)
  • 定义完切片后就可以通过切片对象[脚标]取出或修改切片中元素内容.语法和数组相同

切片是引用类型

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

	names := []string{"hello", "world"}
	names1 := names
	names1[0] = "a"
	fmt.Println(names, names1)//输出:[a world] [a world]
	fmt.Printf("%p %p",names,names1)//地址相同

make函数

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

	slice := make([]string, 0)     //长度为0的切片,没有第三个参数表示容量和长度相等
	slice1 := make([]string, 0, 2) //长度为0,容量为2
	fmt.Println(slice, slice1)
  • 长度表示切片中元素的实际个数,容量表示切片占用空间大小,且切片容量成倍增加.当增加到1024后按照一定百分比增加.
    • len(slice) 查看切片的长度
    • cap(slice) 查看切片的容量
1
2
3
4

	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语言标准库中源码如下
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 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()函数返回值
1
2
3
4
5
6

	s := make([]string, 0)
	fmt.Println(len(s), cap(s))//输出:0 0
	s = append(s, "msr", "MaiShuRen")
	fmt.Println(len(s), cap(s))//输出:2 2
	s = append(s, "MaiShuRen")
	fmt.Println(len(s), cap(s))//输出:3 4
  • 如果添加一次添加多个值,且添加后的长度大于扩容一次的大小,容量和长度相等.等到下次添加内容时如果不超出扩容大小,在现在的基础上进行翻倍
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

	s := make([]string, 0)
	fmt.Println(len(s), cap(s)) //输出:0 0
	s = append(s, "msr", "MaiShuRen")
	fmt.Println(len(s), cap(s)) //输出:2 2
	s = append(s, "MaiShuRen")
	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
  • 也可以把一个切片的内容直接添加到另一个切片中.需要注意语法中有三个点
1
2
3
4

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

通过数组产生切片

  • 定义数组后,取出数组中一个片段,这个片段就是切片类型
1
2
3
4

	names := [3]string{"msr", "MaiShuRen", "Mai"}
	s := names[0:2]     //包前不包后
	fmt.Printf("%T", s) //输出:[]string
	fmt.Println(s)      //输出:[msr MaiShuRen]
  • 切片是指针,指向数组元素地址,修改切片的内容,数组的内容会跟随变化
1
2
3
4
5
6

	names := [3]string{"msr", "MaiShuRen", "Mai"}
	s := names[0:2] //包前不包后
	fmt.Printf("%p %p",s,&names[0])//输出的地址是相同的
	s[0] = "Go语言"
	fmt.Println(s)     //输出:[Go语言 MaiShuRen]
	fmt.Println(names) //输出:[Go语言 MaiShuRen Mai]
  • 当切片内容在增加时
    • 如果增加后切片的长度没有超出数组,修改切片也是在修改数组
    • 如果增加后切片的长度超出数组,会重新开辟一块空间放切片的内容
    • 通过下面代码也正面了切片中内容存在一块连续空间(和数组一样)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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

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

删除实现

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

	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语言标准库源码定义如下
    • 第一个参数是目标切片,接收第二个参数内容
    • 第二个参数是源切片,把内容拷贝到第一个参数中
1
2
3
4
5
6

// 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
  • 拷贝时严格按照脚标进行拷贝.且不会对目标切片进行扩容

代码示例

  • 把短切片拷贝到长切片中
1
2
3
4
5

	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]
  • 把长切片拷贝到短切片中
1
2
3
4
5

	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]
  • 把切片片段拷贝到切片中
1
2
3
4
5

	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函数可以保证原切片内容不变
1
2
3
4
5
6
7

	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) //删除指定元素后的切片

切片的扩容策略

  1. 如果申请的容量大于原来的两倍，那就直接扩容至新申请的容量。如：长度为3，容量为4的切片，现添加6个元素进入，那么长度就会变成9，大于原容量的两倍，所以切片的新容量会也会变成9
  2. 如果小于1024，那么直接扩容两倍
  3. 如果大于1024，就按照1.25被去扩容
  4. 具体存储的值类型不同，扩容策略也有一定的不同

golang学习一：从环境配置开始到HelloWorld入门 golang学习二：golang自带的工具 olang学习三：golang基础语法 golang学习四：流程控制 golang学习五：常用数学函数与数组 golang学习六：for循环 golang学习七：goto和label golang学习八：切片 golang学习九：sort包、map、双向链表、双向循环链表 golang学习十：函数 golang学习十一：包的访问权限、变量作用域、闭包 golang学习十二：值传递和引用传递 golang学习十三：结构体 golang学习十四：golang中的面向对象 golang学习十五：错误异常处理 golang学习十六：文件操作 golang学习十七：反射 golang学习十八：XML操作 golang学习十九：日志 golang学习二十：golang并发编程入门 golang学习二十一：select和GC

Golang
Licensed under CC BY-NC-SA 4.0