golang切片总结

golang切片

本文视频教程：https://www.bilibili.com/video/BV1zR4y1t7Wj?from=search&seid=17015280624326227731&spm_id_from=333.337.0.0

前面我们学习了数组，数组是固定长度，可以容纳相同数据类型的元素的集合。当长度固定时，使用还是带来一些限制，比如：我们申请的长度太大浪费内存，太小又不够用。

鉴于上述原因，我们有了go语言的切片，可以把切片理解为，可变长度的数组，其实它底层就是使用数组实现的，增加了自动扩容功能。切片（Slice）是一个拥有相同类型元素的可变长度的序列。

go语言切片的语法

声明一个切片和声明一个数组类似，只要不添加长度就可以了

var identifier []type

切片是引用类型，可以使用make函数来创建切片：

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

也可以指定容量，其中capacity为可选参数。

make([]T, length, capacity)

这里 len 是数组的长度并且也是切片的初始长度。

go语言切片实例

package main

import "fmt"

func main() {
    var names []string
    var numbers []int
    fmt.Printf("names: %v\n", names)
    fmt.Printf("numbers: %v\n", numbers)
    fmt.Println(names == nil)
    fmt.Println(numbers == nil)
}

运行结果

names: []
numbers: []
true
true

go语言切片的长度和容量

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

实例

package main

import "fmt"

func main() {
    var names = []string{"tom", "kite"}
    var numbers = []int{1, 2, 3}

    fmt.Printf("len: %d cap: %d\n", len(names), cap(names))
    fmt.Printf("len: %d cap: %d\n", len(numbers), cap(numbers))

    var s1 = make([]string, 2, 3)
    fmt.Printf("len: %d cap: %d\n", len(s1), cap(s1))
}

运行结果

len: 2 cap: 2
len: 3 cap: 3
len: 2 cap: 3

golang切片的初始化

切片的初始化方法很多，可以直接初始化，也可以使用数组初始化等。

切片如何切分

// 切片
func test1() {
    var s1 = []int{1, 2, 3, 4, 5, 6}
    s2 := s1[0:3] // [)
    fmt.Printf("s2: %v\n", s2)
    s3 := s1[3:]
    fmt.Printf("s3: %v\n", s3)
    s4 := s1[2:5]
    fmt.Printf("s4: %v\n", s4)
    s5 := s1[:]
    fmt.Printf("s5: %v\n", s5)
}

直接初始化

package main

import "fmt"

func main() {
    s := []int{1, 2, 3}
    fmt.Printf("s: %v\n", s)
}

运行结果

s: [1 2 3]

使用数组初始化

package main

import "fmt"

func main() {
    arr := [...]int{1, 2, 3}
    s1 := arr[:]
    fmt.Printf("s1: %v\n", s1)
}

运行结果

s1: [1 2 3]

使用数组的部分元素初始化（切片表达式）

切片的底层就是一个数组，所以我们可以基于数组通过切片表达式得到切片。 切片表达式中的low和high表示一个索引范围（左包含，右不包含），得到的切片长度=high-low，容量等于得到的切片的底层数组的容量。

package main

import "fmt"

func main() {
    arr := [...]int{1, 2, 3, 4, 5, 6}
    s1 := arr[2:5]
    fmt.Printf("s1: %v\n", s1)
    s2 := arr[2:]
    fmt.Printf("s2: %v\n", s2)
    s3 := arr[:3]
    fmt.Printf("s3: %v\n", s3)
}

运行结果

s1: [3 4 5]
s2: [3 4 5 6]
s3: [1 2 3]

空(nil)切片

一个切片在未初始化之前默认为 nil，长度为 0，容量为0.

package main

import "fmt"

func main() {
    var s1 []int
    fmt.Println(s1 == nil)
    fmt.Printf("len: %d, cap: %d\n", len(s1), cap(s1))
}

运行结果

true
len: 0, cap: 0

go语言切片的遍历

切片的遍历和数组的遍历非常类似，可以使用for循环索引遍历，或者for range循环。

for循环索引遍历

package main

import "fmt"

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    for i := 0; i < len(s1); i++ {
        fmt.Printf("s1[%d]: %v\n", i, s1[i])
    }
}

运行结果

s1[0]: 1
s1[1]: 2
s1[2]: 3
s1[3]: 4
s1[4]: 5

for range循环

package main

import "fmt"

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    for i, v := range s1 {
        fmt.Printf("s1[%d]: %v\n", i, v)
    }
}

运行结果

s1[0]: 1
s1[1]: 2
s1[2]: 3
s1[3]: 4
s1[4]: 5

go语言切片元素的添加和删除copy

切片是一个动态数组，可以使用append()函数添加元素，go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。由于，切片是引用类型，通过赋值的方式，会修改原有内容，go提供了copy()函数来拷贝切片

添加元素

package main

import "fmt"

func main() {
    s1 := []int{}
    s1 = append(s1, 1)
    s1 = append(s1, 2)
    s1 = append(s1, 3, 4, 5) // 添加多个元素
    fmt.Printf("s1: %v\n", s1)

    s3 := []int{3, 4, 5}
    s4 := []int{1, 2}
    s4 = append(s4, s3...) // 添加另外一个切片
    fmt.Printf("s4: %v\n", s4)
}

运行结果

s1: [1 2 3 4 5]
s4: [1 2 3 4 5]

删除元素

package main

import "fmt"

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    // 删除索引为2的元素
    s1 = append(s1[:2], s1[3:]...)
    fmt.Printf("s1: %v\n", s1)
}

运行结果

s1: [1 2 4 5]

公式：要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)

拷贝切片

package main

import "fmt"

func main() {
    s1 := []int{1, 2, 3}
    s2 := s1
    s1[0] = 100
    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s2: %v\n", s2)
    fmt.Println("----------")

    s3 := make([]int, 3)

    copy(s3, s1)

    s1[0] = 1

    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s3: %v\n", s3)
}

运行结果

s1: [100 2 3]
s2: [100 2 3]
-------------
s1: [1 2 3]
s3: [100 2 3]

从运行结果，我们看到赋值的情况下，原来的变量被修改了，使用copy函数，原来的变量没有被修改。

关注公众号，学习更多golang知识