Go语言学习笔记四--数组与切片
数组
创建数组
- 定义数组也准寻golang的基本定义习惯,变量类型在前,变量名在后
/**
创建一个数组
*/
func createArrays() {
//第一种 定义数组
var arr1 [5]int //不指定数组值,默认int为0
//第二种 定义数组方式
arr2 := [3]int{1, 2, 3} //设置初始值
//可变长度的数组
arr3 := [...]int{1, 2, 3, 4, 5}
//二维数组
var arr4 [4][5]int //创建一个4行,5列的二维数组
}
遍历数组
- 遍历数组可以使用原始的fori形式,但是一般不这么做,golang中定义关键字
range可以遍历数组 - 为什么使用
range- 意义明确,美观
- c++没有这个能力
- java/python中有类似的for each value 但是不能同时取出 k ,v
//原始fori的形式
for i:=0;i< len(arr3);i++ {
fmt.Println(arr3[i])
}
//遍历 之遍历出值 使用range关键字
for e := range arr3 {
fmt.Println(e)
}
//关键字range遍历出 下标与值
for k, v := range arr3 {
//k下标 v 值
fmt.Println(k,v)
}
数组是值类型
- 注意这一点与Java不同,在Java中数组是
引用类型(Golang学习笔记三有复习到Java中值类型与引用类型) - 值类型意味着,传递参数时数组是拷贝份,被调用函数中修改数组调用方法上不会被修改
golang值传递方式实验
func printArr(ints [5]int) { //使用数组作为参数,就需要指定数量 ,
//[5]int类型如果传入[3]int就会报错.
//如果不想被数量限制可以使用 [...]int作为参数类型
for k, v := range ints {
fmt.Println(k, v)
}
}
func updateArr(ints [5]int) {
ints[0] = 1000
fmt.Println("-------------update success----------")
}
func main() {
arr3 := [...]int{1, 2, 3, 4, 5}
printArr(arr3)
fmt.Println("---------------update before--------------")
updateArr(arr3)
fmt.Println("---------------update after--------------")
printArr(arr3)
}
打印结果:
0 1
1 2
2 3
3 4
4 5
---------------update before--------------
-------------update success----------
---------------update after--------------
0 1 //下标0发现确实是没有改变的
1 2
2 3
3 4
4 5
golang指针传递方式
func updateArrByPointer(ints *[5]int) {
ints[0] = 1000 //可以发现在golang中使用数组指针,直接使用变量名就好不需要再`*ints`来转换
fmt.Println("-------------update success----------")
}
func main() {
arr3 := [...]int{1, 2, 3, 4, 5}
printArr(arr3)
fmt.Println("---------------update before--------------")
updateArrByPointer(&arr3) //传入arr指针
fmt.Println("---------------update after--------------")
printArr(arr3)
}
打印结果:
0 1
1 2
2 3
3 4
4 5
---------------update before--------------
-------------update success----------
---------------update after--------------
0 1000 //修改成功
1 2
2 3
3 4
4 5
对比Java修改数组
以下为Java代码
@Test
public void testAdd(){
int[] ints = new int[5];//Java创建数组,初始不指定初始全部为0
updateArr(ints);
System.out.println(Arrays.toString(ints)); //打印结果[100, 0, 0, 0, 0]
}
private void updateArr(int[] ints) {
ints[0]=100;
}
小结
- [10]int与[5]int是不同类型
- go语言中数组为值类型,Java中数组为引用类型,调用
fun f(arr [10]int)会 拷贝 数组 - 因为这些麻烦,一般在go语言中不直接使用数组,而是使用 切片
slice(切片)
如何定义一个slice
arr := [...]int{0,1,2,3,4,5,6,7}
s1 := arr[2:6]// [3 4 5 6]左闭右开,一般计算机语言中都是这么定义
//slice不是值类型,底层是对其数组的封装
由上可知,slice定义是int[:] 关键是在数组括号中加上:冒号,更多定义形式:
func main() {
arr := [...]int{0,1,2,3,4,5,6,7}
s1 := arr[2:6]// [3 4 5 6]左闭右开,一般计算机语言中都是这么定义
//slice不是值类型,底层是对其数组的封装
fmt.Println("arr[2:6]:",s1)
s2 := arr[:6]
fmt.Println("arr[:6]:", s2)
s3 := arr[2:]
fmt.Println("arr[2:]:", s3)
s4 := arr[:]
fmt.Println("arr[:]:", s4)
}
打印信息:
arr[2:6]: [2 3 4 5] //当左右都限制数字时,打印截取的是arr的下标 [2,5)元素,左闭右开
arr[:6]: [0 1 2 3 4 5] //当不限制左边,不填写左边数字,实际打印截取arr下标[0,6)元素
arr[2:]: [2 3 4 5 6 7] //不限制右边,不填写右边数字,实际打印截取arr下标[2,8)
arr[:]: [0 1 2 3 4 5 6 7] //两边都不限制时,截取所有
如何使用slice
slice修改数组
在调用函数中修改切片内容
func updateSlice(ints []int) { //[]int 表示slice类型
ints[2] = 100
}
func main() {
arr := [...]int{0,1,2,3,4,5,6,7}
s1 := arr[2:6]// [3 4 5 6]左闭右开,一般计算机语言中都是这么定义
//slice不是值类型,底层是对其数组的封装
s2 := arr[:6]
s3 := arr[2:]
s4 := arr[:]
fmt.Println("s1:",s1)
fmt.Println("------------updateSlice before----------")
updateSlice(s1) //修改slice s1
fmt.Println("------------updateSlice after----------")
fmt.Println("s1:",s1)
fmt.Println("s2:",s2)
fmt.Println("s3:",s3)
fmt.Println("s4:",s4)
fmt.Println("arr:",arr)
/**
- slice不是值类型,go语言中除了slice所有都是值类型(slice的特殊之处就提现在这个地方)
- slice在内部,是有一个数据结构的,是对arr的一个view(视图)
*/
}
控制台打印为:
s1: [2 3 4 5]
------------updateSlice before----------
------------updateSlice after----------
s1: [2 3 100 5]
s2: [0 1 2 3 100 5]
s3: [2 3 100 5 6 7]
s4: [0 1 2 3 100 5 6 7]
arr: [0 1 2 3 100 5 6 7]
奇妙的事情发生了,所有视图中,对应的arr下标中第4个元素都被修改成了100,由此实验,我们也可以更好的理解什么叫做slice为对应数组的视图.
如果觉得不懂我们可以一步步推导一下:
s1 := arr[2:6]// [3 4 5 6]s1[2] 对应的 arr[4]fun updateSlice中将s1[2]修改成100,视图(顾名思义对arr数组的引用,而不是拷贝),所以对应的arr[4]被赋值为100(这里是语言表达便于,其实arr[4]就是s1[2]).- 接着因为s2是对arr的[0,6)的视图,故arr[4]就是s2[4],所以s2[4]=100.
- 其他s3,s4同理
reslice
reslice顾名思义,就是在slice的基础上继续slice
func main() {
arr := [...]int{0,1,2,3,4,5,6,7}
s4 := arr[:]
fmt.Println("arr[:]:", s4)
s4 = s4[:6]
fmt.Println("reslice 1 s4:",s4)
s4 = s4[2:]
fmt.Println("reslice 2 s4:",s4)
}
控制台打印
arr[:]: [0 1 2 3 4 5 6 7]
reslice 1 s4: [0 1 2 3 4 5]
reslice 2 s4: [2 3 4 5]
slice的拓展
思考下面代码会如何打印?
func main() {
//拓展
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
fmt.Println("s1,s2:",s1,s2)
}
先猜测一下,s1我们知道很简单[2 3 4 5],但是s2是对s1的slice而s1只有4个元素最大下标为3,s2却要取到其下标4,能否成功呢?
先执行看结果:
s1,s2: [2 3 4 5] [5 6] //打印结果是没有报错的,而且从结果分析,s1的第4下标元素是arr的第6下标
尝试打印s1[4]是否成功
fmt.Println("s1[4]",s1[4])
可以看到报错是不能打印下标4元素的
panic: runtime error: index out of range
goroutine 1 [running]:
main.main()
D:/IdeaProduct/learngo/container/slices.go:54 +0x15c
所以这里就需要引出slice的底层数据结构来解释:
slice底层数据结构:
slice拓展过程:
由上图可以看出len() cap()分别指什么位置,ptr指的是什么
- len() 指slice的长度
- cap() 指slice可拓展的长度
- ptr 指slice在view的数组中开始位置
代码检验:
func main() {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
fmt.Println("arr:",arr)
fmt.Printf("s1 v:%v, len(s1):%d, cap(s1):%d\n",s1,len(s1),cap(s1))
fmt.Printf("s2 v:%v, len(s2):%d, cap(s2):%d\n",s2,len(s2),cap(s2))
}
arr: [0 1 2 3 4 5 6 7]
s1 v:[2 3 4 5], len(s1):4, cap(s1):6 通过结果也印证了我们上诉所说的 len cap的概念
s2 v:[5 6], len(s2):2, cap(s2):3
slice其他操作,添加元素
append
func main() {
//添加
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
ss1 := append(s1, 10)
ss2 := append(ss1, 10)
fmt.Println("arr:",arr)
fmt.Println("s1:",s1)
fmt.Println("s2:",s2)
fmt.Println("ss1:",ss1)
fmt.Println("ss2:",ss2)
}
arr: [0 1 2 3 4 5 10 10]
s1: [2 3 4 5]
s2: [5 10]
ss1: [2 3 4 5 10] ss1 //是对s1的追加,我们发现其追加完后会再次返回一个slice
//且看到arr这个数组的后面两个值被改变了 而arr数组改变,s2也会就会跟着变化
ss2: [2 3 4 5 10 10]
我们再添加一个元素,这时已经超过的arr的长度
func main() {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
ss1 := append(s1, 10)
ss2 := append(ss1, 10)
ss3 := append(ss2, 10)
fmt.Println("arr:",arr)
fmt.Println("s1:",s1)
fmt.Println("s2:",s2)
fmt.Println("ss1:",ss1)
fmt.Println("ss2:",ss2)
fmt.Println("ss3:",ss3)
fmt.Printf("ss3 v:%v, len(ss3):%d, cap(ss3):%d\n",ss3,len(ss3),cap(ss3))
fmt.Printf("arr v:%v, len(arr):%d, cap(arr):%d\n",arr,len(arr),cap(arr))
}
arr: [0 1 2 3 4 5 10 10]
s1: [2 3 4 5]
s2: [5 10]
ss1: [2 3 4 5 10]
ss2: [2 3 4 5 10 10]
ss3: [2 3 4 5 10 10 10] //当我们继续添加一个元素,因为此时已经是超过arr的长度
//此时,打印发现arr不再变化,而返回的ss3是追加上的
ss3 v:[2 3 4 5 10 10 10], len(ss3):7, cap(ss3):12
//打印出ss3的信息可以看出,其实已经是一个行的slice了,跟arr没有任何关系
//疑问 为什么 cap为12?
//要回答为什么是12我们得再做一个实验
解答cap得长度秘密
func main() {
var s []int
for i := 0; i < 10; i++ {
fmt.Printf("s v:%v, len(s):%d, cap(s):%d\n",s,len(s),cap(s))
s = append(s, i)
}
}
s v:[], len(s):0, cap(s):0
s v:[0], len(s):1, cap(s):1
s v:[0 1], len(s):2, cap(s):2
s v:[0 1 2], len(s):3, cap(s):4
s v:[0 1 2 3], len(s):4, cap(s):4
s v:[0 1 2 3 4], len(s):5, cap(s):8
s v:[0 1 2 3 4 5], len(s):6, cap(s):8
s v:[0 1 2 3 4 5 6], len(s):7, cap(s):8
s v:[0 1 2 3 4 5 6 7], len(s):8, cap(s):8
s v:[0 1 2 3 4 5 6 7 8], len(s):9, cap(s):16
打印结果可以发现,其实cap是有规律得变化得.
初始时我们创建了一个空的slice s ,再golang中没有null得概念,有nil(nil会初始化数据),但是nil是可以调用赋值的
cap开始0 后面1 超过1cap后变成2 后面是4,由此可以看出,cap的长度是,当cap长度不足时,扩充2倍
create
//create slice
s1 = arr[:]
s1 = make([]int, 12) //第一个参数指定len长度
s1 = make([]int, 12,16) //第二个参数可以指定 cap
copy
//copy slice
arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 = arr[:]
copyArr := make([]int, 12,16)
copy(copyArr, s1) //copy参数,第一个是被赋值的对象,第二个是数据源
fmt.Println(copyArr)
delete(删除中间,删除头 尾)
删除中间元素
fmt.Println(copyArr)
//将copyArr 中第三个元素删掉
copyArr = append(copyArr[:3], copyArr[4:]...)
//删除其中元素是没有函数的
//所以我们可以间接的实现,截取前半部分与后半部分,然后再合起来
//我们看到append 第二个参数slice后面有...三个点,
//这是因为在append函数第二个参数不能传入slice但是可以加上三个点就可以了
fmt.Println(copyArr)
[0 1 2 3 4 5 6 7 0 0 0 0]
[0 1 2 4 5 6 7 0 0 0 0]
取出头元素/取出尾元素
//取出头元素
//popping from front
fmt.Println("copyArr", copyArr)
front := copyArr[0]
copyArr = copyArr[1:]
fmt.Println("front:", front)
fmt.Println("after popping from front, copyArr:", copyArr)
//取出最后一个元素
//poping from back
tail := copyArr[len(copyArr)-1]
copyArr = copyArr[:len(copyArr)-1]
fmt.Println("tail:" ,tail)
fmt.Println("after poping from back ,copyArr:",copyArr)
copyArr [0 1 2 4 5 6 7 0 0 0 0]
front: 0
after popping from front, copyArr: [1 2 4 5 6 7 0 0 0 0]
tail: 0
after poping from back ,copyArr: [1 2 4 5 6 7 0 0 0]
总结slice是什么
- slice不是值类型
- slice是对数组的封装
- slice是数组的一个view
- 拓展slice时,可以超过len,但不能超过cap
- 追加元素append函数,会返回一个新的slice,且如果append的slice在底层数组长度范围内时,会修改底层数组
- 追加元素超过底层数组时,go会创建一个新的slice,且长度是不够cap的2倍
- 创建slice时可以用
make函数,并指定len与cap
作者所有的学习源码在 go学习源码github地址,如果觉得有用的话帮小智贡献一个star?