Golang 之 切片

切片

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]，相应示意图如下。

slice_01

 

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

slice_02

 

切片的比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和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这个包。 记得把数组变成切片。