8.Golang数组array、切片slice、字典map 数据操作

一、数组 array

声明数组时，必须声明数组大小，声明后大小不可变，未赋值的空间默认值为数组存储类型的 0 值。

1. 数组是值类型数据，相同空间大小的数组可以用 == 来比较是否相同。

package main

import "fmt"

func main() {
    var a1 = [2]int{1, 2}
    var a2 = [2]int{1, 2}
    fmt.Println(a1 == a2) // 输出：true
}

2.数组遍历

package main

import "fmt"

func main() {
    // range 推荐
    arr := [3]string{"aa", "bb", "cc"}
    for index, v := range arr {
        fmt.Printf("index:%d, value:%s\n", index, v)
    }

    // for
    for i := 0; i < len(arr); i++ {
        v := arr[i]
        fmt.Printf("index:%d, value:%s\n", i, v)
    }

}

3.数组追加元素

数组大小固定，所以只能指定元素操作。

package main

import (
    "fmt"
)

func main() {
    var arr = [5]int{1, 2}
    arr[2] = 3
    arr[3] = 4
    fmt.Println(arr) // 输出：[1 4 3 4 0]
}

4.数组指针

package main

import (
    "fmt"
)

func main() {
    // 数组指针之间的赋值不会拷贝底层数组的值
    var a1 = &[3]int{1, 2, 3} // 取数组地址
    var a2 *[3]int            // 定义一个数组指针
    a2 = a1                   // 使 a2 指向 a1 地址
    a1[2] = 9
    fmt.Println(*a1) // 输出:[1 2 9]
    fmt.Println(*a2) // 输出:[1 2 9]
}

二、切片 slice

切片可以看作是一个可变长的数组，是一个引用类型。它包含三个数据：1.指向数组的指针，2.切片中的元素，3.切片的大小。

1.切片遍历

package main

import "fmt"

func main() {
    sl := []int{1, 2, 3}

    // range
    for i, v := range sl {
        fmt.Printf("index:%d, value:%d\n", i, v)
    }

    for i := 0; i < len(sl); i++ {
        v := sl[i]
        fmt.Printf("index:%d, value:%d\n", i, v)
    }
}

2.插入、删除元素

只要内存足够，切片可以追加任意个元素。

package main

import "fmt"

func main() {
    // 切片末尾追加元素
    sl := make([]int, 0)
    sl = append(sl, 1)
    sl = append(sl, 2, 3)
    fmt.Println(sl) // 输出：[1 2 3]

    // 在索引位置 i 插入元素 x：s = append(s[:i], append([]T{x}, s[i:]...)...)
    // 在索引位置 1 插入元素 4：
    sl = append(sl[:1], append([]int{4}, sl[1:]...)...)
    fmt.Println(sl) // 输出：[1 4 2 3]

    // 在索引位置 i 插入长度为 j 的切片：s = append(s[:i], append(make([]T, j), s[i:]...)...)
    // 在索引位置 2 插入长度为 3 的切片：
    var sl1 = []int{11, 22, 33}
    sl = append(sl[:2], append(sl1, sl[2:]...)...)
    fmt.Println(sl) // 输出：[1 4 11 22 33 2 3]

    // 删除索引位置 i 上元素：s = append(s[:i], s[i+1:]...)
    // 删除索引位置 1 上的元素：
    sl = append(sl[:1], sl[1+1:]...)
    fmt.Println(sl) // 输出：[1 11 22 33 2 3]

    // 删除索引位置 i 到 j 上的元素，杀出元素不包括索引 j 上的元素：s = append(s[:i],s[j:]...)
    // 删除索引位置 2 到 4 上的元素：
    sl = append(sl[:2], sl[4:]...)
    fmt.Println(sl) // 输出：[1 11 2 3]

    // 复制切片，将 a 切片上的元素拷贝到 b 切片上：copy(b, a)
    // 如果切片长度不等，a 长度大于 b 则拷贝len(b) 长度个 a 切片中的元素给 b
    // 如果 a 长度小于 b 则拷贝 a 中元素到 b 中，b 中超出的元素部分保持原值不变
    var a, b []int
    a = []int{1, 2, 3, 4}
    b = []int{11, 22}
    copy(b, a)
    fmt.Println(b) // 输出：[1,2]

    c := make([]int, 5)
    c = []int{11, 22, 33, 44, 55}
    copy(c, a)
    fmt.Println(c) // 输出：[1 2 3 4 55]
}

3.排序

Go 语言 sort 包提供了 sort.Ints() 、sort.Float64s() 和 sort.Strings() 函数，都是从小到大排序：

package main

import (
    "fmt"
    "sort"
)

func main() {
    intList := []int{5, 3, 2, 1, 4}
    float64List := []float64{5.1, 1.2, 2.34, 4.22, 3.12}
    stringList := []string{`a`, `e`, `d`, `c`, `b`}

    // 正序，从小到大排序
    sort.Ints(intList)
    sort.Float64s(float64List)
    sort.Strings(stringList)
    fmt.Println(intList)     // 输出：[1 2 3 4 5]
    fmt.Println(float64List) // 输出：[1.2 2.34 3.12 4.22 5.1]
    fmt.Println(stringList)  // 输出：[a b c d e]

    // 倒叙，从大到小排序
    sort.Sort(sort.Reverse(sort.IntSlice(intList)))
    sort.Sort(sort.Reverse(sort.Float64Slice(float64List)))
    sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
    fmt.Println(intList)     // 输出：[5 4 3 2 1]
    fmt.Println(float64List) // 输出：[5.1 4.22 3.12 2.34 1.2]
    fmt.Println(stringList)  // 输出：[e d c b a]
}

三、字典 map

字典操作：

package main

import "fmt"

func main() {
    m := make(map[string]int, 2)

    // 插入元素
    m["a"] = 11
    m["b"] = 22

    // 遍历 map
    for index, v := range m {
        fmt.Printf("index:%s v%d:\n", index, v)
    }

    // 删除 map 中数据
    delete(m, "a")
    fmt.Println(m) // 输出：map[b:22]
}