Golang Slice切片

Posted 2021-03-05 zhichaoma

1. 切片的定义和初始化

• 切片是基于数组类型的封装，非常灵活，可以自动扩容
• 切片是真正意义上的动态数组，而且是一个引用类型，切片指向一个底层数组

定义切片

var 切片名[] 切片类型

创建切片方式

package main

import "fmt"

func main() {
    // 1. 声明切片
    var s1 []int
    if s1 == nil { // 只声明没有初始化，所以是nil
        fmt.Println("为空")
    } else {
        fmt.Println("不为空")
    }

    // 2. := 自动推导
    s2 := []int{}

    // 3. make(切片类型, 长度, 容量)
    // 容量是可选的
    var s3 []int = make([]int, 0)

    fmt.Println(s1, s2, s3)

    // 4. 初始化赋值
    var s4 []int = make([]int, 0, 0)
    fmt.Println(s4)

    s5 := []int{1,2,3}
    fmt.Println(s5)

    // 5. 从数组切片
    arr := [5]int{1,2,3,4,5}
    var s6 []int
    s6 = arr[1:4]
    fmt.Println(s6)
}

2. 切片操作

操作	含义
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()
cap(s)	切片 s 的容量，总是>=len(s)

package main

import "fmt"

func op01() {
    // 定义数组
    array := [...]int{1, 2, 3, 4, 5, 6, 7, 9, 0}

    // 切片
    fmt.Println(array[:])
    fmt.Println(array[1:5])
    fmt.Println(array[:6])
    fmt.Println(array[2:])
    fmt.Println(array[2])
}

func op02() {
    s1 := make([]int, 3, 5)
    fmt.Printf("s1: %v, len: %d, cap: %d", s1, len(s1), cap(s1))
}

func op03() {
    // 初始化一个数组
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8}

    s1 := arr[2:5]
    fmt.Println(s1)

    // 可以向后扩展，默认是不扩展，不可以向前扩展
    s2 := s1[2:7]
    fmt.Println(s2)
}

func main() {
    op01()
    op02()
    op03()
}

3. append()函数

向 slice 尾部添加数据，返回新的 slice 对象

package main

import "fmt"

func main() {
    // 空切片
    var s001 []int

    s001 = append(s001, 1)
    s001 = append(s001, 3)
    s001 = append(s001, 6)
    fmt.Println(s001)

    // 初始化内存的切片
    s002 := make([]int, 5)
    s002 = append(s002, 5, 8, 9)
    fmt.Println(s002)

    // 初始化默认值的切片
    s003 := []int{1, 3, 6}
    s003 = append(s003, 4, 99, 2)
    fmt.Println(s003)
}

package main

import "fmt"

func main() {
    // 初始化一个数组
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8}

    // 初始化一个从数组切片的slice
    s1 := arr[2:]
    fmt.Println(arr)
    fmt.Println(s1)

    // 修改s1切片的值
    // view(视图)操作，会修改原数组的值
    s1[0] = 100
    fmt.Println(s1)
    fmt.Println(arr)
}

// 输出结果
// [0 1 2 3 4 5 6 7 8]
// [2 3 4 5 6 7 8]
// [100 3 4 5 6 7 8]
// [0 1 100 3 4 5 6 7 8]

package main

import "fmt"

func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:6]
    fmt.Println(s1)
    s2 := s1[3:5]
    fmt.Println(s2)

    // 映射到底层是覆盖操作
    s3 := append(s2, 10)
    fmt.Println(s3)
    fmt.Println(arr)
    fmt.Println()

    // 底层去自动扩容, 此时打印的是原数组
    s4 := append(s3, 11)
    fmt.Println(s4)
    fmt.Println(arr)

    s5 := append(s4, 12)
    fmt.Println(s5)
    fmt.Println(arr)
}

package main

import "fmt"

func main() {
    var a []int = []int{1, 2, 3}
    var b []int = []int{4, 5, 6}

    a = append(a, 7, 8)
    fmt.Println(a)

    // append无法直接添加一个切片，需要使用...将切片打散
    a = append(a, b...)
    fmt.Println(a)
}

4. copy()函数

在两个 slice 间复制数据，两个 slice 可指向同一底层数组

package main

import "fmt"

func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
    s1 := arr[8:] // [8 9 10 11 12 13 14]
    s2 := arr[:5] // [0 1 2 3 4]
    fmt.Println(s1, s2)

    // 从左侧开始覆盖
    copy(s1, s2)
    fmt.Println(s1, s2) // [0 1 2 3 4 13 14] [0 1 2 3 4]
    fmt.Println(arr)    // [0 1 2 3 4 5 6 7 0 1 2 3 4 13 14]
}

5. 切片扩容机制

用 make()创建切片，可以指定容量，当容量存储到上限，底层会自动扩容

package main

import "fmt"

func main() {
    var a []int = make([]int, 5, 10)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))

    a[0] = 10
    a[1] = 20
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))

    a = append(a, 30)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))

    for i := 0; i <= 8; i++ {
        a = append(a, i)
        fmt.Printf("for a=%v, len=%d, cap=%d
", a, len(a), cap(a))

    }
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))
}

切片再切片

package main

import "fmt"

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

    // 切片再切片
    b = b[:cap(b)]
    fmt.Printf("b=%v, len=%d, cap=%d
", b, len(b), cap(b))
}

空切片的扩容机制

package main

import "fmt"

func main() {
    var a []int
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))

    a = append(a, 10)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))
    a = append(a, 20)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))
    a = append(a, 30)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))
    a = append(a, 40)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))
    a = append(a, 50)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))
    a = append(a, 60)
    fmt.Printf("a=%v, len=%d, cap=%d
", a, len(a), cap(a))
}