总目录:https://www.jianshu.com/p/e406a9bc93a9

Golang - 子目录:https://www.jianshu.com/p/8b3e5b2b4497

切片

go语言的切片与Python的切片看起来是一样的,但是却截然不同,Python的切片操作是一种深拷贝行为,切出来就是切出来了,go语言的切片操作是一种引用行为。

为什么会有切片

go语言中的数组是定长序列,查询快但是不易操作,例如我们不能对他进行追加元素。
所以就有了切片,相比于数组,切片是一个不定长序列,同时他是基于数组的封装,也就是说他有了数组的操作速度的同时更加的灵活。
我们上面也说go语言的切片是一种引用类型,所以他的内部结构是地址,长度和容量。一般使用切片来进行对一块数据的快速操作。

切片的定义

语法:
var 切片名 []数据类型

例子:

package main
import "fmt"
func main() {
 var s1 []int //定义一个整数类型的切片
 var s2 []string //定义一个字符串类型的切片
 fmt.Println(s1, s2)
}
----------
[][]

切片的初始化

切片的初始化没有什么需要注意的,需要注意的是初始化之后的切片,哪怕是空值,他也不等于nil了。
例子:

package main
import "fmt"
func main() {
 // 切片的定义
 var s1 []int //定义一个整数类型的切片
 var s2 []string //定义一个字符串类型的切片
 // 切片的初始化
 s1 = []int{1, 2, 3} //对已经创建的切片赋值
 var s3 = []string{} //创建时初始化,并且赋空值
 var s4 = []bool{false, true} //创建时初始化,并且赋值
 fmt.Println(s1, s2, s3, s4)
 fmt.Println(s1 == nil)
 fmt.Println(s2 == nil)
 fmt.Println(s3 == nil)
 fmt.Println(s4 == nil)
}
-----------
[1 2 3] [] [] [false true]
false
true
false
false

切片的长度与容量

既然我们说切片是一个不定长数据类型,那么我们肯定需要知道某个切片的长度。但实际上切片除了长度这个属性外,还有一个属性--容量。

package main
import "fmt"
func main() {
 // 切片的定义
 var s1 []int //定义一个整数类型的切片
 // 切片的初始化
 s1 = []int{1, 2, 3} //对已经创建的切片赋值
 // 切片的长度与容量
 fmt.Printf("len(s1):%d,cap(s1):%d",len(s1),cap(s1))
}
----------
len(s1):3,cap(s1):3

乍一看,长度和容量都是3,好像没有什么不同,这就需要来看我们另外一种定义方式---基于数组定义切片。

基于数组定义切片

基于数组的切片操作起来和Python基于序列的切片一样,遵循左闭右开规则,切的都是索引。

package main
import "fmt"
func main() {
 // 基于数组定义切片
 // 定义一个数组
 arr1 := [5]int{1, 2, 3, 4, 5}
 // 基于一个数组定义切片 遵循左闭右开规则
 s1 := arr1[1:4]
 fmt.Println(s1)
 fmt.Printf("%T\n", s1)
 fmt.Printf("len(s1):%d,cap(s1):%d", len(s1), cap(s1))
}
----------
[2 3 4]
[]int
len(s1):3,cap(s1):4

但是运行完后,我们发现切片的长度为3,但是容量为4了。
这是因为容量是从数组中切片的首元素下标开始数,数到数组的尾下标。s1的容量是4,具体点是2, 3, 4, 5这四个元素所占的长度。

这是我们再来看看,他是不是和Python一样,都有步长:

但是看样子是不可以的,他说这样是无效的,那么我们把它们颠倒一下。
颠倒之后并没有报错,然后我看来一下官方文档,切片操作的第三个参数是用来限制切片的容量。
允许限制新切片的容量为底层数组提供了一定的保护,可以更好地控制追加操作。

package main
import "fmt"
func main() {
 arr1 := [5]int{1, 2, 3, 4, 5}
 // 限制切片的容量
 s2 := arr1[1:2:3]
 fmt.Println(s2)
 fmt.Printf("%T\n", s2)
 fmt.Printf("len(s2):%d,cap(s2):%d", len(s2), cap(s2))
}
----------
[2]
[]int
len(s2):1,cap(s2):2

如果没有第三个参数的话,容量会一直到数组末位,但是设置第三个参数,就会到第三个参数标注的索引处。

接着让我们来看一下一些通用操作:

package main
import "fmt"
func main() {
 arr1 := [5]int{1, 2, 3, 4, 5}
 fmt.Println(arr1[2:]) //从第二个索引取到末位,包括第二个索引
 fmt.Println(arr1[:4]) //从头取到第四个索引,不包括第四个索引
 fmt.Println(arr1[:]) //从头取到未
}
----------
[3 4 5]
[1 2 3 4]
[1 2 3 4 5]

基于切片再切片

package main
import "fmt"
func main() {
// 切片再切片
 // 定义一个数组
 arr2 := [...]int{1,2,3,4,5,6,7,8,9,10}
 // 切片
 s3 := arr2[:7]
 fmt.Println("s3:",s3)
 // 切片在切片
 s4 := s3[3:5]
 fmt.Println("s4:",s4)
 s5 := s3[1:9]
 fmt.Println("s5:",s5)
 // 一个限制容量的切片
 s6 := arr2[:7:8]
 fmt.Println("s6:",s6)
 // 在切片 这里会报错,因为s6的容量只到8.
 s7 := s6[1:9]
 fmt.Println("s7:",s7)
}
----------
s3: [1 2 3 4 5 6 7]
s4: [4 5]
s5: [2 3 4 5 6 7 8 9]
s6: [1 2 3 4 5 6 7]
panic: runtime error: slice bounds out of range [:9] with capacity 8

切片再切片并不是在原来的切片上面切片,因为切片是引用类型,所以再切片也是在底层数组上进行切片的。
同时如果切片限制了容量,那么再切片不能超过这个容量,否则会越界。
再切片也不能超过数组的长度。

既然切片是引用类型,那么我们修改一下切片里的元素呢

package main
import "fmt"
func main() {
 arr2 := [...]int{1,2,3,4,5,6,7,8,9,10}
 // 如果修改了切片的元素呢
 fmt.Printf("没有修改的s6[3]:%d\n",s6[3])
 s6[3] = 100
 fmt.Printf("修改过的s6[3]:%d\n",s6[3])
 fmt.Println("修改过的数组:",arr2)
}
----------
没有修改的s6[3]:4
修改过的s6[3]:100
修改过的数组: [1 2 3 100 5 6 7 8 9 10]

使用make()函数构造切片

make()函数就是一个内置的用来创建切片的函数。

语法
make ([]T, size, cap)
T:切片的元素类型
size:切片中元素的数量
cap:切片的容量

例子:

package main
import "fmt"
func main() {
 // make函数
 a := make([]int, 2, 10)
 fmt.Printf("len(a):%d,cap(a):%d\n", len(a), cap(a))
}
----------
len(a):2,cap(a):10

如果不写容量,则默认长度就是容量。

package main
import "fmt"
func main() {
 // make函数
 a := make([]int, 2)
 fmt.Printf("len(a):%d,cap(a):%d\n", len(a), cap(a))
}
----------
len(a):2,cap(a):2

切片的本质

切片的本质就是对底层数组的封装,它包含了三个信息:底层数组的指针、切片的长度(len)和切片的容量(cap)。

举个例子,现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7},切片s1 := a[:5],相应示意图如下。

切片s2 := a[3:6],相应示意图如下:

切片的比较

切片之间是不能比较的,我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组,一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil,例如下面的示例:

var s1 []int //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{} //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

所以要判断一个切片是否是空的,要是用len(s) == 0来判断,不应该使用s == nil来判断。

切片的赋值

切片是引用类型,只要他们是从同一个底层散发出去的,他们的修改操作就会影响底层。

package main
import "fmt"
func main() {
 // 切片赋值
 ms1 := make([]int, 3) //[0 0 0]
 ms2 := ms1 //将s1直接赋值给s2,s1和s2共用一个底层数组
 ms2[0] = 100
 fmt.Println(ms1) //[100 0 0]
 fmt.Println(ms2) //[100 0 0]
}
----------
[100 0 0]
[100 0 0]

切片的遍历

因为底层还是数组,所以遍历的方式与结果与数组一致。

package main
import "fmt"
func main() {
 // 切片遍历
 s := []int{1, 3, 5}
 for i := 0; i < len(s); i++ {
 fmt.Println(i, s[i])
 }
 for index, value := range s {
 fmt.Println(index, value)
 }
}
----------
0 1
1 3
2 5
0 1
1 3
2 5

append()

Go语言的内建函数append()可以为切片动态添加元素。 可以一次添加一个元素,可以添加多个元素,也可以添加另一个切片中的元素(后面加...)。

package main
import "fmt"
func main() {
 s1 := []string{"北京", "上海", "深圳"}
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
 // 按照原来的写法,对数组进行扩容可以:
 // s1[3] = "广州" //但是go中数组是定长类型,所以不能这么写
 // 正确的写法: 使用一个变量接受返回值,一般用原来的切片接受返回值
 s1 = append(s1, "广州") // 进行扩容之后的切片,就不再是原来的切片了。
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
 // 添加多个元素
 s1 = append(s1, "成都", "重庆")
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
 // 添加另一个切片中的元素
 s2 := []string{"石家庄", "保定", "邢台"}
 s1 = append(s1, s2...)
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
}
----------
len(s1):3,cap(s1):3
len(s1):4,cap(s1):6
len(s1):6,cap(s1):6
len(s1):9,cap(s1):12

注意:append()函数可以直接作用于没有初始化的切片。

每个切片会指向一个底层数组,这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时,切片就会自动按照一定的策略进行"扩容",此时该切片指向的底层数组就会更换。"扩容"操作往往发生在append()函数调用时,所以我们通常都需要用原变量接收append函数的返回值。

例子:

func main() {
 //append()添加元素和切片扩容
 var numSlice []int
 for i := 0; i < 10; i++ {
 numSlice = append(numSlice, i)
 fmt.Printf("%v len:%d cap:%d ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
 }
}
----------
[0] len:1 cap:1 ptr:0xc0000a8000
[0 1] len:2 cap:2 ptr:0xc0000a8040
[0 1 2] len:3 cap:4 ptr:0xc0000b2020
[0 1 2 3] len:4 cap:4 ptr:0xc0000b2020
[0 1 2 3 4] len:5 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5] len:6 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5 6] len:7 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5 6 7] len:8 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5 6 7 8] len:9 cap:16 ptr:0xc0000b8000
[0 1 2 3 4 5 6 7 8 9] len:10 cap:16 ptr:0xc0000b8000

append()函数将元素追加到切片的最后并返回该切片。
切片numSlice的容量按照1,2,4,8,16这样的规则自动进行扩容,每次扩容后都是扩容前的2倍。

切片的扩容策略

我们先看go语言关于扩容的一段源码:

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
 newcap = cap
} else {
 if old.len < 1024 {
 newcap = doublecap
 } else {
 // Check 0 < newcap to detect overflow
 // and prevent an infinite loop.
 for 0 < newcap && newcap < cap {
 newcap += newcap / 4
 }
 // Set newcap to the requested cap when
 // the newcap calculation overflowed.
 if newcap <= 0 {
 newcap = cap
 }
 }
}

• 首先判断,如果新申请容量(cap)大于2倍的旧容量(old.cap),最终容量(newcap)就是新申请的容量(cap)。
• 否则判断,如果旧切片的长度小于1024,则最终容量(newcap)就是旧容量(old.cap)的两倍,即(newcap=doublecap),
• 否则判断,如果旧切片长度大于等于1024,则最终容量(newcap)从旧容量(old.cap)开始循环增加原来的1/4,即(newcap=old.cap,for {newcap += newcap/4})直到最终容量(newcap)大于等于新申请的容量(cap),即(newcap >= cap)
• 如果最终容量(cap)计算值溢出,则最终容量(cap)就是新申请容量(cap)。

需要注意的是,切片扩容还会根据切片中元素的类型不同而做不同的处理,比如int和string类型的处理方式就不一样。

大白话一下就是:
1.如果要的容量是原来容量的两倍还要多,那么把他要的给他:

 s1 := []string{"北京", "上海", "深圳"}
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
 s1 = append(s1, "广州","成都", "重庆","石家庄", "保定", "邢台","张家口") 
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
----------
len(s1):3,cap(s1):3
len(s1):10,cap(s1):10

他最开始有3容量,然后一次性插入7个元素,比他本来的容量的两倍大,那么就用现在的容量直接覆盖原来的容量。

2.如果要的容量没有原来容量两倍大,那就扩充到原来容量的两倍。

 s1 := []string{"北京", "上海", "深圳"}
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
 s1 = append(s1, "广州","成都") 
 fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
----------
len(s1):3,cap(s1):3
len(s1):10,cap(s1):6

3.如果原来的容量大于1024,那么每次提升25%,不再是提升100%。
也就是原来是2000的容量,扩充会先扩充到2500,不够再扩充到3000,不会一下翻两倍到4000。

copy()

关于拷贝的用法,可以参考我的深浅拷贝那一节,理解了Python的深浅拷贝,就能秒懂这个。

package main
import "fmt"
func main() {
 // copy
 a := []int{1, 2, 3, 4, 5}
 c := make([]int, 5, 5)
 copy(c, a) //使用copy()函数将切片a中的元素复制到切片c
 fmt.Printf("a:%v,len(a):%d,cap(a):%d\n", a,len(a), cap(a))
 fmt.Printf("c:%v,len(c):%d,cap(c):%d\n", c,len(c), cap(c))
 c[0] = 1000 // copy操作之后的切片c和切片a之间没有任何关系 是两个独立的切片
 fmt.Printf("a:%v,len(a):%d,cap(a):%d\n", a,len(a), cap(a))
 fmt.Printf("c:%v,len(c):%d,cap(c):%d\n", c,len(c), cap(c))
}
----------
a:[1 2 3 4 5],len(a):5,cap(a):5
c:[1 2 3 4 5],len(c):5,cap(c):5
a:[1 2 3 4 5],len(a):5,cap(a):5
c:[1000 2 3 4 5],len(c):5,cap(c):5

删除元素

Go语言中并没有删除切片元素的专用方法,我们可以使用切片本身的特性来删除元素。

 // 删除元素
 s := []int{1,2,3,4,5,6,7,8}
 // 使用append间隔追加
 s = append(s[:1],s[2:]...)
 fmt.Printf("s:%v,len(s):%d,cap(s):%d\n", s,len(s), cap(s))
---------
s:[1 3 4 5 6 7 8],len(s):7,cap(s):8

练习题

1.请写出下面代码的输出结果。

func main() {
 var a = make([]string, 5, 10)
 for i := 0; i < 10; i++ {
 a = append(a, fmt.Sprintf("%v", i))
 }
 fmt.Println(a)
}

[ 0 1 2 3 4 5 6 7 8 9]
// 最开始的a是一个有五个空字符串的切片。
// 切片里面能放多少元素,是容量说的算

2.请使用内置的sort包对数组var a = [...]int{3, 7, 8, 9, 1}进行排序

 var a1 = [...]int{3, 7, 8, 9, 1}
 sort.Ints(a1[:])
 fmt.Println(a1)
要导入sort这个包。 记得把数组变成切片。

本文来自:简书

感谢作者:寒暄_HX

查看原文:3.2.6Golang的切片

• 编辑
• 预览