原来go语言slice切片底层原理这么简单

发布时间:2022-01-16 07:52:49 作者:路人甲 阅读(118)

前言

本篇博客不会贴出go的源码,只会告诉你slice用法,因为我们学习一项技术主要学的是编程的思想,眼花缭乱的源码千篇一律,深入人心的思想万里挑一,博客种通过图文的方式介绍底层机制,为的是能让开发人员写出属于自己的技术,而不是生搬硬套去复制别人的代码,相信等你理解了底层原理之后,你完全可以自己写一个动态数组出来,这就是我写博客的初心!

slice是什么

在go语言中,如果想要使用一个连续的内存空间,你可以使用数组,但是数组是固定长度的,无法做到动态扩容。因此切片slice就出现了,你可以先给切片设置一个初始容量,然后往里面添加元素,当切片容量不足时会自动扩容,来装载加入的元素;

用法

  1. // 初始化长度为5,容量为10的切片
  2. strings := make([]string, 5, 10)
  3. // 创建string类型的切片,长度为5,容量为5
  4. strings1 := make([]string, 5)
  5. // 添加元素
  6. strings = append(strings , "元素")
  7. // 修改元素
  8. strings[1] = "修改的元素"

删除元素

切片本身并没有提供删除的方法,但是我们可以自己实现一个

  1. func main(){
  2. strings := make([]string, 0, 2)
  3. strings = append(strings, "one")
  4. strings = append(strings, "two")
  5. strings = append(strings, "three")
  6. strings = append(strings, "four")
  7. newStrings := deleteSlice(strings, "three")
  8. fmt.Println(newStrings)
  9. }
  10. /**
  11. * 删除指定切片的元素
  12. * strings 原切片
  13. * 需要删除的元素
  14. */
  15. func deleteSlice(strings []string, delStr string) []string{
  16. newStrings := make([]string, 0, len(strings))
  17. // 删除元素 three--排除需要删除的元素,将其他元素赋值给新的切片
  18. for _, v := range strings {
  19. if v != delStr {
  20. newStrings = append(newStrings, v)
  21. }
  22. }
  23. fmt.Printf("删除后的元素%v \n", newStrings)
  24. fmt.Println(len(newStrings))
  25. return newStrings
  26. }

切片底层用什么结构?

在开始的时候就有介绍过,切片属于动态数组,所以他的底层就是一个数组,在内存中是一段连续的内存空间
在这里插入图片描述

长度 和 容量的区别

切片的长度指的是已初始化元素长度大小,什么意思呢?比如下面这个语句

  1. strings := make([]string, 5, 10)

这个语句表示切片的长度未5,容量为10,

  • 切片的容量指的就是底层数组的长度,容量为10,就表示底层数组的长度就是10
  • 切片的长度指的是已初始化的元素个数,从下图可以看到,前5个元素已经分配了内存空间,并赋予初始值 ""(空字符串),所以它的长度是5
    在这里插入图片描述

可通过以下方式得出切片长度和容量

  1. strings := make([]string, 5, 10)
  2. fmt.Printf("长度:%d, 容量:%d",len(strings),cap(strings))

打印结果如下:

  1. 长度:5, 容量:10

扩容机制

以上了解了那么多,那么切片的在内部是如何进行扩容的呢?接下来就来揭晓它内部的秘密,首先我们声明一个切片,长度为1,容量为2,然后往这个容量中添加4次元素,看看有什么样的变化

  1. strings := make([]string, 1, 2)
  2. for i := 0; i < 4; i++ {
  3. strings = append(strings,"1")
  4. fmt.Printf("第%d次添加元素,长度:%d,容量:%d \n",i + 1,len(strings),cap(strings))
  5. }
  6. fmt.Println(strings)

控制台打印结果如下

第1次添加元素,长度:2,容量:2
第2次添加元素,长度:3,容量:4
第3次添加元素,长度:4,容量:4
第4次添加元素,长度:5,容量:8
[ 0 1 2 3 ]

扩容分析

通过以上案例,我们可以分解出每次操作后底层的数组都做了哪些事

0、创建切片

首先,当我们创建好切片后,长度为1,容量为2,长度为1就表示第0个元素已经初始化好了,已经赋值为空字符串了,此时结构如下图
在这里插入图片描述

1、第一次添加元素"0"

因为第0个下标的的位置已经被占用了,所以添加的元素就会往后面排,因此会先给下标1的元素先初始化,然后将"0"的值为放到1的位置上,此时大家会发现,容量已经满了,但是这时候还没触发扩容;
在这里插入图片描述

2、第二次添加元素"1"

在添加元素前,会先判断数组的容量是否足够,因为这时候容量已经满了,所以一定会触发扩容,扩容原理如下

  1. 创建一个新的数组,容量为原数组的2倍
  2. 将原数组的内容复制到新数组
  3. 将新添加的元素加入到新数组的后面
  4. 原数组因为没在使用,稍后gc会将其回收

扩容后的结构如下图 (==白色部分表示未分配内存空间==)
在这里插入图片描述

3、第三次添加元素"2"

这一步是正常的追加元素,追加到后面,和第一次添加元素时一样,容量又满了,但是还未触发扩容
在这里插入图片描述

4、第四次添加元素"3"

同样地,在添加元素前,会先判断数组的容量是否足够,因为这时候容量已经满了,所以会再次触发扩容
在这里插入图片描述

每次扩容都扩一倍吗?

不是的,,如果每次都扩一倍的话,将会占用大量的内存空间,而很有可能这些空间我们都用不到;所以go语言为了防止数组冗余,做了一些处理
在这里插入图片描述

  • 当数组容量小于1024时,每次扩容一倍
  • 当数组容量大于等于1024时,每次扩容0.25倍,也就是扩容四分之一的容量

多说无益,我们来测试下

  1. strings := make([]string, 1, 2)
  2. for i := 0; i < 1024; i++ {
  3. strings = append(strings,fmt.Sprint(i))
  4. }
  5. fmt.Printf("经过1024次添加元素,长度:%d,容量:%d \n",len(strings),cap(strings))

打印结果如下,按照计算公式: 1024 * 1.25 = 1280,扩容后就是1280的容量

经过1024次添加元素,长度:1025,容量:1280

切片会缩容吗?

切片不会缩容,扩容后的数组空间,哪怕你不用,也是安安静静地占用着内存空间的,不会进行缩容;

关键字Go