Go语言学习笔记-006切片

最新推荐文章于 2023-03-29 11:12:53 发布

藤藤菜丶

最新推荐文章于 2023-03-29 11:12:53 发布

阅读量837

点赞数 1

分类专栏：总结分享学习 Go 文章标签： golang

本文链接：https://blog.csdn.net/Star_SDK/article/details/120273838

版权

总结分享学习同时被 2 个专栏收录

39 篇文章 1 订阅

订阅专栏

10 篇文章 0 订阅

订阅专栏

Go语言基础之切片

因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性，例如对数组之求部分的和。

package main

import "fmt"

func arraySum(x [3]int) int {
    var sum int
    for _, v := range x {
        sum += v
    }
    return sum
}

func main() {
    a := [...]int{1,2,3}
    arraySum(a)
}

这个求和函数只能接受[3]int类型，其他的都不支持。

切片

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度、容量。切片一般用于快速地操作一块数据集合。

切片的定义

声明切片类型的基本语法如下：

var name []T

其中：

name: 表示变量名
T: 表示切片中的元素类型

package main

import "fmt"

func main() {
    var a []string
    var b = []int{}
    var c = []bool{false, true}
    var d = []bool{false, true}
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(a == nil)
    fmt.Println(b == nil)
    fmt.Println(c == nil)
	// fmt.Println(c == d)   //切片是引用类型，不支持直接比较，只能和nil比较
}

输出：

[]
[]
[false true]
[false true]
true
false
false

切片的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。

切片表达式

切片表达式从字符串、数组、指向数组或切片的指针构造子字符串或切片。它有两种变体：一种指定low和high两个索引界限值的简单的形式，另一种是除了low和high索引界限值之外还指定容量的完整的形式。

简单切片表达式

切片的地产就是一个和数组，索引我们可以基于数组通过切片表达式得到切片。切片表达式中的low和high表示一个索引范围（左包含，右不包含）。如下：

package main

import "fmt"

func main() {
    a := []int{9,8,7,6,5,4,3,2,1,0}
    b := a[0:3]
    fmt.Printf("b:%v len(b):%v cap(b):%v", b, len(b), cap(b))
}

输出：

b:[9 8 7] len(b):3 cap(b):10

为了方便起见，可以省略切片表达式中的任何索引。省略了low则默认为0；省略了high则默认为切片操作数的长度：

a[4:]  // a[4:len(a)]
a[:4]  // a[0:4]
a[:]  // a[0:len(a)]

注意：

对于数组或字符串，如果0 <= low <= high <= len(a)，则索引合法，否则就会索引越界（out of range）。

对切片执行切片表达式时（切片再切片），high的上限边界是切片的容量cap(a)，而不是长度。常量索引必须是非负的，并且可以用int类型的值表示；对于数组或常量字符串，常量索引也必须再有效范围内。如果low和high两个指标都是常数，它们必须满足low <= high。如果索引在运行的时候曹操范围，就会发生运行时panic恐慌。

package main

import "fmt"

func main() {
    a := []int{1,2,3,4,5,6,7,8,9,0}
    b := a[5:7]
    fmt.Printf("b:%v len(b):%v cap(b):%v \n", b, len(b), cap(b))
    c := b[2:4]
    fmt.Printf("c:%v len(c):%v cap(c):%v \n", c, len(c), cap(c))
}

输出：

b:[6 7] len(b):2 cap(b):5 
c:[8 9] len(c):2 cap(c):3

完整切片表达式

对于数组，指向数组的指针，或切片a（注意不能是字符串）支持完整切片表达式：

a[low: high: max]

上面的代码会构造与简单切片表达式a[low:high]相同类型、相同长度和元素的切片。另外，它会将得到的结果切片的容量设置为max-low。在完整切片表达式中只有第一个索引值（low）可以省略；它默认为0。

package main

import "fmt"

func main() {
    a := []int{1,2,3,4,5,6,7,8,9,0}
    b := a[1:4:5]
    fmt.Printf("b:%v len(b):%v cap(b):%v \n", b, len(b), cap(b))
}

输出：

b:[2 3 4] len(b):3 cap(b):4

使用make()函数构造切片

动态的创建一个切片，需要使用内置的make()函数，格式如下：

make([]T, size, cap)

其中：

T: 切片的元素类型
size: 切片中元素的数量
cap: 切片的容量

如：

package main

import "fmt"

func main() {
    a := make([]int, 2, 10)
    fmt.Println(a)
    fmt.Println(len(a))
    fmt.Println(cap(a))
}

输出：

[0 0]
2
10

上面的代码中a的内部存储空间已经分配了10个，但实际上只用了2个。容量并不会影响当前元素的个数，所以len(a)返回2，cap(a)则返回该切片的容量。

切片的本质

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

如：a :=[]int{1,2,3,4,5,6,7,8,9,0}, 切片b := a[:5]。
在这里插入图片描述
切片c := a[3:5]，相应示意图如下：

判断切片是否为空

要检查切片是否为空，请终始使用len(s) == 0来判断，而不应该使用s == nil 来判断。

切片不能直接比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。切片唯一合法的比较操作是和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() {
    s1 := make([]int, 3)
    s2 := s1
    s2[0] = 100
    fmt.Println(s1)
    fmt.Println(s2)
}

输出：

[100 0 0]
[100 0 0]

切片遍历

切片的遍历方式和数组是一致的，支持索引遍历和for range遍历。

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)
    }
}

append()方法为切片添加元素

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

package main

import "fmt"

func main() {
    var s []int
    s = append(s, 1)  // [1]
    s = append(s, 2, 3, 4)  // [1 2 3 4]
    s2 := []int{5, 6, 7}
    s = append(s, s2...)  // [1 2 3 4 5 6 7]
}

注意：

通过var声明的零值切片可以在append()函数直接使用，无需初始化。

var s []int
s = append(s, 1, 2, 3)

没必要像下面的代码一样初始化一个切片再传入append()函数使用。

s := []int{}  // 没必要实例化
s = append(s, 1, 2, 3)

var s = make([]int)  // 没必要实例化
s = append(s, 1, 2, 3)

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

package main

import "fmt"

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:0xc000084020
[0 1]  len:2  cap:2  ptr:0xc000084060
[0 1 2]  len:3  cap:4  ptr:0xc000090020
[0 1 2 3]  len:4  cap:4  ptr:0xc000090020
[0 1 2 3 4]  len:5  cap:8  ptr:0xc000092040
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc000092040
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc000092040
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc000092040
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc000082080
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc000082080

根据输出可以看出：

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

append()函数也支持一次性追加多个元素。如：

package main

import "fmt"

func main() {
	var citySlice []string
	// 追加一个元素
	citySlice = append(citySlice, "南岸区")
	// 追加多个元素
	citySlice = append(citySlice, "渝北区", "渝中区"，"江北区")
	// 追加切片
	a := []string{"巴南区", "九龙坡区"}
    citySlice = append(citySlice, a...)
    fmt.Println(citySlice)  // [南岸区 渝北区 渝中区 江北区 巴南区 九龙坡区]
}

切片的扩容策略

可以通过查看$GOROOT/src/runtime/slice.go源码181行，其中扩容相关代码如下：

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
    newcap = cap
} else {
    if old.cap < 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)，最终容量就是新申请的容量(cap)
否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即(newcap=doublecap)
否则判断，如果旧切片长度大于等于1024，则最终容量(newcap)从旧容量(old.cap)开始循环增加原来的1/4，即(newcap=oldcap, for {newcap+=newcap/4})直到最终容量(newcap)大于等于新申请的容量(cap)，即(newcap >= cap)
如果最终容量(cap)计算值溢出，则最终容量(cap)就是新申请容量(cap)。

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

使用copy()函数复制切片

内建的copy()函数可以迅速的将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

srcSlice:数据来源切片
destSlice:目标切片

如：

package main

import "fmt"

func main() {
    // copy() 复制切片
    a := []int{1, 2, 3, 4, 5}
    b := make([]int, 5, 5)
    copy(b, a)
    fmt.Println(a)
    fmt.Println(b)
    b[0] = 1000
    fmt.Println(a)
    fmt.Println(b)
}

输出：

[1 2 3 4 5]
[1 2 3 4 5]
[1 2 3 4 5]
[1000 2 3 4 5]

从切片中删除元素

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

package main

import "fmt"

func main() {
    // 从切片中删除元素
    a := []int{20,21,22,23,24,25,26,27,28,29,30}
    fmt.Println(a)
    // 要删除索引为5的元素
    a = append(a[:5], a[6:]...)
    fmt.Println(a)
}

输出为：

[20 21 22 23 24 25 26 27 28 29 30]
[20 21 22 23 24 26 27 28 29 30]

(a)
fmt.Println(b)
}


输出：

[1 2 3 4 5]
[1 2 3 4 5]
[1 2 3 4 5]
[1000 2 3 4 5]


### 从切片中删除元素

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

```go
package main

import "fmt"

func main() {
    // 从切片中删除元素
    a := []int{20,21,22,23,24,25,26,27,28,29,30}
    fmt.Println(a)
    // 要删除索引为5的元素
    a = append(a[:5], a[6:]...)
    fmt.Println(a)
}

输出为：

[20 21 22 23 24 25 26 27 28 29 30]
[20 21 22 23 24 26 27 28 29 30]

藤藤菜丶

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Go语言学习笔记-006切片

Go语言基础之切片因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性，例如对数组之求部分的和。package mainimport "fmt"func arraySum(x [3]int) int { var sum int for _, v := range x { sum += v } return sum}func main() { a := [...]int{1,2,3} arraySum(a)
复制链接

扫一扫

专栏目录