Go入门（五）-- 数组切片Slice

最新推荐文章于 2024-04-01 21:06:30 发布

KOOK(峰)

最新推荐文章于 2024-04-01 21:06:30 发布

阅读量279

点赞数 1

文章标签：开发语言 golang 后端

本文链接：https://blog.csdn.net/qq_45264054/article/details/132397869

版权

slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。

数组切片的数据结构可以抽象为3个变量：

一个指向原生数组的指针
数组切片中的元素个数
数组切片已分配的存储空间

创建数组切片

基于数组

数组切片可以基于一个已存在的数组创建。数组切片可以只是用数组的一部分元素或者整个数组来创建，甚至可以创建一个比所基于的数组还要大的数组切片。下面代码展示了如何基于一个数组的前5个元素创建一个数组切片。

package main

import "fmt"

func main() {
    // 先定义一个数组
    var myArray = [10]int{1,2,3,4,5,6,7,8,9,10}

    // 基于数组创建一个数组切片
    var mySlice []int = myArray[:5]

    fmt.Println("Elements of myArray")
    for _,v := range myArray {
        fmt.Print(v," ")
    }

    fmt.Println("Elements of mySlice")
        for _,v := range mySlice {
        fmt.Print(v," ")
    }
}

/*
输出结果：
Elements of myArray
1 2 3 4 5 6 7 8 9 10
Elements of mySlice
1 2 3 4 5
*/

Go 语言支持用 myArray[first:last] 这样的方式来基于数组生成一个数组切片，而且用法灵活。

基于myArray的所有元素创建数组切片：mySlice = myArray[:]
基于myArray的前5个元素创建数组切片：mySlice = myArray[:5]
基于从第5个元素开始的所有元素创建数组切片：mySlice = myArray[5:]

直接创建

Go 语言提供了内置函数 make()可以用于灵活的创建数组切片，而不需要一个数组。

var slice []type = make([]type, len)
slice  := make([]type, len)
slice  := make([]type, len, cap)

示例代码

package main

import "fmt"

func main() {
    s1 := []int{0, 1, 2, 3, 8: 100} // 通过初始化表达式构造，可使用索引号。
    fmt.Println(s1, len(s1), cap(s1))

    s2 := make([]int, 6, 8) // 使用 make 创建，指定 len 和 cap 值。
    fmt.Println(s2, len(s2), cap(s2))

    s3 := make([]int, 6) // 省略 cap，相当于 cap = len。
    fmt.Println(s3, len(s3), cap(s3))
}

/*
输出结果：
[0 1 2 3 0 0 0 0 100] 9 9
[0 0 0 0 0 0] 6 8
[0 0 0 0 0 0] 6 6
*/

使用 make 动态创建slice，避免了数组必须用常量做长度的麻烦。还可用指针直接访问底层数组，退化成普通数组操作。

示例代码

package main

import "fmt"

func main() {
    s := []int{0, 1, 2, 3}
    p := &s[2] // *int, 获取底层数组元素指针。
    *p += 100

    fmt.Println(s)

    data := [...]int{0, 1, 2, 3, 4, 5}

    s1 := data[2:4]
    s1[0] += 100
    s1[1] += 200

    fmt.Println(s1)
    fmt.Println(data)
}

/*
输出结果：
[0 1 102 3]
[102 203]
[0 1 102 203 4 5]
*/

至于 [][]T，是指元素类型为 []T。

示例代码

package main

import (
    "fmt"
)

func main() {
    data := [][]int{
        []int{1, 2, 3},
        []int{100, 200},
        []int{11, 22, 33, 44},
    }
    fmt.Println(data)
}

/*
输出结果：
[[1 2 3] [100 200] [11 22 33 44]]
*/

可直接修改 struct array/slice 成员。

示例代码

package main

import (
    "fmt"
)

func main() {
    d := [5]struct {
        x int
    }{}

    s := d[:]

    d[1].x = 10
    s[2].x = 20

    fmt.Println(d)
    fmt.Printf("%p, %p\n", &d, &d[0])

}


/*
输出结果：
[{0} {10} {20} {0} {0}]
0xc4200160f0, 0xc4200160f0
*/

基于数组切片创建数组切片

类似于数组切片可以基于一个数组创建，数组切片也可以基于另一个数组切片创建。示例如下：

oldSlice := []int{1,2,3,4,5}
newSlice := oldSlice[:3]   // 基于oldSlice的前三个元素构建新的数组切片

切片初始化

全局：
var arr = [...]int{0,1,2,3,4,5,6,7,8,9}
var slice0 []int = arr[start:end]
var slice1 []int = arr[:end]
var slice2 []int = arr[start:]
var slice3 []int = arr[:]
var slice4 = arr[:len(arr)-1]  // 去掉切片的最后一个元素
局部：
arr2 := [...]int{9,8,7,6,5,4,3,2,1,0}
slice5 := arr[start:end]
slice6 := arr[:end]
slice7 := arr[start:]
slice8 := arr[:]
slice9 := arr[:len(arr)-1] // 去掉切片的最后一个元素

操作	含义
s[n]	切片 s 中索引位置为n的项
s[:]	从切片 s 的索引位置 0 到 len(s)-1 处所获得的切片（全部）
s[low:]	从切片 s 的索引位置 low 到 len(s-1) 处所获得的切片
s[:high]	从切片 s 的索引位置 0 到 high 处所获得的切片，len=high
s[low:high]	从切片 s 的索引位置 low 到 high 处所获得的切片，len=high-low
s[low:high:max]	从切片 s 的索引位置 low 到 high 处所获得的切片，len=high-low，cap=max-low
len(s)	切片 s 的长度，总是 <= cap(s)
cap(s)	切片 s 的容量，总是 >= len(s)

示例代码：

package main

import (
    "fmt"
)

var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
var slice0 []int = arr[2:8]
var slice1 []int = arr[0:6]        //可以简写为 var slice []int = arr[:end]
var slice2 []int = arr[5:10]       //可以简写为 var slice[]int = arr[start:]
var slice3 []int = arr[0:len(arr)] //var slice []int = arr[:]
var slice4 = arr[:len(arr)-1]      //去掉切片的最后一个元素
func main() {
    fmt.Printf("全局变量：arr %v\n", arr)
    fmt.Printf("全局变量：slice0 %v\n", slice0)
    fmt.Printf("全局变量：slice1 %v\n", slice1)
    fmt.Printf("全局变量：slice2 %v\n", slice2)
    fmt.Printf("全局变量：slice3 %v\n", slice3)
    fmt.Printf("全局变量：slice4 %v\n", slice4)
    fmt.Printf("-----------------------------------\n")
    arr2 := [...]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
    slice5 := arr[2:8]
    slice6 := arr[0:6]         //可以简写为 slice := arr[:end]
    slice7 := arr[5:10]        //可以简写为 slice := arr[start:]
    slice8 := arr[0:len(arr)]  //slice := arr[:]
    slice9 := arr[:len(arr)-1] //去掉切片的最后一个元素
    fmt.Printf("局部变量： arr2 %v\n", arr2)
    fmt.Printf("局部变量： slice5 %v\n", slice5)
    fmt.Printf("局部变量： slice6 %v\n", slice6)
    fmt.Printf("局部变量： slice7 %v\n", slice7)
    fmt.Printf("局部变量： slice8 %v\n", slice8)
    fmt.Printf("局部变量： slice9 %v\n", slice9)
}

/*
输出结果：
全局变量：arr [0 1 2 3 4 5 6 7 8 9]
全局变量：slice0 [2 3 4 5 6 7]
全局变量：slice1 [0 1 2 3 4 5]
全局变量：slice2 [5 6 7 8 9]
全局变量：slice3 [0 1 2 3 4 5 6 7 8 9]
全局变量：slice4 [0 1 2 3 4 5 6 7 8]
-----------------------------------
局部变量： arr2 [9 8 7 6 5 4 3 2 1 0]
局部变量： slice5 [2 3 4 5 6 7]
局部变量： slice6 [0 1 2 3 4 5]
局部变量： slice7 [5 6 7 8 9]
局部变量： slice8 [0 1 2 3 4 5 6 7 8 9]
局部变量： slice9 [0 1 2 3 4 5 6 7 8]
*/

元素遍历

操作数组元素的所有方法都适用于数组切片，比如数组切片也可以按下标读写元素，用 len() 函数获取元素个数，并支持使用 range 关键字来快速遍历所有元素。

传统的元素遍历方法（for）：

for i := 0; i < len(mySlice); i++ {
    fmt.Println("mySlice[",i,"] = ",mySlice[i])
}

使用 range 可以让遍历代码显得更简洁。

for i,v := range mySlice {
    fmt.Println("mySlice[",i,"] = ",v)
}

动态增减元素

可动态增减元素是数组切片比数组更为强大的功能。与数组相比，数组切片多了一个存储能力（capacity）的概念，即元素个数和分配的空间可以是两个不同的值。合理的设置存储能力的值，可以大幅降低数组切片内部重新分配内存和搬运内存块的频率，从而大大提高程序性能。

Go 语言是用 append() 内置函数操作切片（追加）。可以按自己的需求增加若干个元素，甚至直接将一个数组切片追加到另一个数组切片的末尾，不过需要在第一个参数后加 ...

示例代码

package main

import (
    "fmt"
)

func main() {

    var a = []int{1, 2, 3}
    fmt.Printf("slice a : %v\n", a)
    var b = []int{4, 5, 6}
    fmt.Printf("slice b : %v\n", b)
    c := append(a, b...)
    fmt.Printf("slice c : %v\n", c)
    d := append(c, 7)
    fmt.Printf("slice d : %v\n", d)
    e := append(d, 8, 9, 10)
    fmt.Printf("slice e : %v\n", e)

}


/*
输出结果：
slice a : [1 2 3]
slice b : [4 5 6]
slice c : [1 2 3 4 5 6]
slice d : [1 2 3 4 5 6 7]
slice e : [1 2 3 4 5 6 7 8 9 10]
*/

数组切片会自动处理内存空间不足的问题。如果追加的内容长度超过当前已分配的存储空间（即 cap() 调用返回的信息），数组切片会自动分配一块足够大的内存。

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 10: 0}
    s := data[:2:3]

    s = append(s, 100, 200) // 一次 append 两个值，超出 s.cap 限制。

    fmt.Println(s, data)         // 重新分配底层数组，与原数组无关。
    fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。

}


/*
[0 1 100 200] [0 1 2 3 4 0 0 0 0 0 0]
0xc4200160f0 0xc420070060
*/

从输出结果可以看出，append 后的 s 重新分配了底层数组，并复制数据。如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配。通常以 2 倍容量重新分配底层数组。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。

slice 中 cap 重新分配规律。

package main

import (
    "fmt"
)

func main() {

    s := make([]int, 0, 1)
    c := cap(s)

    for i := 0; i < 50; i++ {
        s = append(s, i)
        if n := cap(s); n > c {
            fmt.Printf("cap: %d -> %d\n", c, n)
            c = n
        }
    }
}

/*
输出结果：
cap: 1 -> 2
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64
*/

数组和切片的内存布局

字符串和切片（string and slice）

string 底层就是一个 byte 的数组，因此，也可以进行切片操作

package main

import (
    "fmt"
)

func main() {
    str := "hello world"
    s1 := str[0:5]
    fmt.Println(s1)

    s2 := str[6:]
    fmt.Println(s2)
}

/*
输出结果：
hello
world
*/

string 本事是不可变的，因此要改变 string 中字符。需要如下操作：英文字符串：

package main

import (
    "fmt"
)

func main() {
    str := "Hello world"
    s := []byte(str) //中文字符需要用[]rune(str)
    s[6] = 'G'
    s = s[:8]
    s = append(s, '!')
    str = string(s)
    fmt.Println(str)
}

/*
输出结果：
Hello Go!
*/

含有中文字符串

package main

import (
    "fmt"
)

func main() {
    str := "你好，世界！hello world！"
    s := []rune(str) 
    s[3] = '够'
    s[4] = '浪'
    s[12] = 'g'
    s = s[:14]
    str = string(s)
    fmt.Println(str)
}

/*
输出结果：
你好，够浪！hello go
*/

golang slice data[:6:8] 两个冒号的理解

常规slice , data[6:8]，从第6位到第8位（返回6， 7），长度len为2，最大可扩充长度cap为4（6-9）

另一种写法： data[:6:8] 每个数字前都有个冒号， slice内容为data从0到第6位，长度len为6，最大扩充项cap设置为8

a[x:y:z] 切片内容 [x:y] 切片长度: y-x 切片容量:z-x

package main

import (
    "fmt"
)

func main() {
    slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    d1 := slice[6:8]
    fmt.Println(d1, len(d1), cap(d1))
    d2 := slice[:6:8]
    fmt.Println(d2, len(d2), cap(d2))
}

数组 or 切片转字符串

strings.Replace(strings.Trim(fmt.Sprint(array_or_slice), "[]"), " ", ",", -1)

总结

切片：切片是数组的一个引用，因此切片是引用类型。但自身是结构体，值拷贝传递
切片的长度可以改变：切片是一个可变数组
切片的遍历方式和数组一样，可以用 len() 求长度。表示可用元素数量，读写操作不能超过该限制
cap 可以求出 slice最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中array是slice引用的数组
切片的定义：var 变量名 []类型，比如 var str []string var arr []int
如果 slice == nil，那么 len、cap 结果都等于 0

KOOK(峰)

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Go入门（五）-- 数组切片Slice

切片：切片是数组的一个引用，因此切片是引用类型。但自身是结构体，值拷贝传递切片的长度可以改变：切片是一个可变数组切片的遍历方式和数组一样，可以用len()求长度。表示可用元素数量，读写操作不能超过该限制cap可以求出slice最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中array是slice引用的数组切片的定义：var 变量名 []类型，比如 var str []string var arr []int。
复制链接

扫一扫