Golang 容器

Posted 2021-04-25 Golang发烧友

Golang Map：引用类型，哈希表。一堆键值对的未排序集合。
键必须是支持相等运算符 ("=="、"!=") 类型， 如 number、string、 pointer、array、struct，以及对应的 interface。值可以是任意类型，没有限制。

map声明
声明map的语法如下

var map变量名 map[key] value
其中：key为键类型，value为值类型
例如：value不仅可以是标注数据类型，也可以是自定义数据类型

package main
type personInfo struct {
    ID      string
    Name    string
    Address string
}
var m1 map[string]int
var m2 map[string]personInfo
func main() {}

map初始化

直接初始化（创建）

package main
import (
    "fmt"
)
var m1 map[string]float32 = map[string]float32{"C": 5, "Go": 4.5, "Python": 4.5, "C++": 2}
func main() {
    m2 := map[string]float32{"C": 5, "Go": 4.5, "Python": 4.5, "C++": 2}
    m3 := map[int]struct {
        name string
        age  int
    }{
        1: {"user1", 10}, // 可省略元素类型。
        2: {"user2", 20},
    }
    fmt.Printf("全局变量 map m1 : %v\n", m1)
    fmt.Printf("局部变量 map m2 : %v\n", m2)
    fmt.Printf("局部变量 map m3 : %v\n", m3)
}

输出结果：

全局变量 map m1 : map[Python:4.5 C++:2 C:5 Go:4.5]
局部变量 map m2 : map[C++:2 C:5 Go:4.5 Python:4.5]
局部变量 map m3 : map[2:{user2 20} 1:{user1 10}]
注意：由m1,m2可以看出map是键值对的无序集合。

通过make初始化（创建）

Go语言提供的内置函数make()可以用于灵活地创建map。
预先给 make 函数一个合理元素数量参数，有助于提升性能。因为事先申请一大块内存，可避免后续操作时频繁扩张。

package main
import (
    "fmt"
)
func main() {
    // 创建了一个键类型为string,值类型为int的map
    m1 := make(map[string]int)
    // 也可以选择是否在创建时指定该map的初始存储能力，如创建了一个初始存储能力为5的map
    m2 := make(map[string]int, 5)
    m1["a"] = 1
    m2["b"] = 2
    fmt.Printf("局部变量 map m1 : %v\n", m1)
    fmt.Printf("局部变量 map m2 : %v\n", m2)
}

输出结果：

局部变量 map m1 : map[a:1]
局部变量 map m2 : map[b:2]

map操作：
插入、更新、查找、删除、判断是否存在、求长度

package main
import (
    "fmt"
)
func main() {
    m := map[string]string{"key0": "value0", "key1": "value1"}
    fmt.Printf("map m : %v\n", m)
    //map插入
    m["key2"] = "value2"
    fmt.Printf("inserted map m : %v\n", m)
    //map修改
    m["key0"] = "hello world!"
    fmt.Printf("updated map m : %v\n", m)
    //map查找
    val, ok := m["key0"]
    if ok {
        fmt.Printf("map's key0 is %v\n", val)
    }
    // 长度：获取键值对数量。
    len := len(m)
    fmt.Printf("map's len is %v\n", len)
    // cap 无效，error
    // cap := cap(m)    //invalid argument m (type map[string]string) for cap
    // fmt.Printf("map's cap is %v\n", cap)
    // 判断 key 是否存在。
    if val, ok = m["key"]; !ok {
        fmt.Println("map's key is not existence")
    }
    // 删除，如果 key 不存在，不会出错。
    if val, ok = m["key1"]; ok {
        delete(m, "key1")
        fmt.Printf("deleted key1 map m : %v\n", m)
    }
}

输出结果：

map m : map[key0:value0 key1:value1]
inserted map m : map[key0:value0 key1:value1 key2:value2]
updated map m : map[key0:hello world! key1:value1 key2:value2]
map's key0 is hello world!
map's len is 3
map's key is not existence
deleted key1 map m : map[key0:hello world! key2:value2]

map遍历：

不能保证迭代返回次序，通常是随机结果，具体和版本实现有关。

package main
import (
    "fmt"
)
func main() {
    m := make(map[int]int)
    for i := 0; i < 10; i++ {
        m[i] = i
    }
    fmt.Println(m)
    fmt.Println(m)
    for j := 0; j < 2; j++ {
        fmt.Println("---------------------")
        for k, v := range m {
            fmt.Printf("key -> value : %v -> %v\n", k, v)
        }
    }
}

输出结果：

map[6:6 8:8 2:2 1:1 3:3 4:4 5:5 7:7 9:9 0:0]
map[2:2 6:6 8:8 5:5 7:7 9:9 0:0 1:1 3:3 4:4]
---------------------
key -> value : 2 -> 2
key -> value : 6 -> 6
key -> value : 8 -> 8
key -> value : 9 -> 9
key -> value : 0 -> 0
key -> value : 1 -> 1
key -> value : 3 -> 3
key -> value : 4 -> 4
key -> value : 5 -> 5
key -> value : 7 -> 7
---------------------
key -> value : 8 -> 8
key -> value : 2 -> 2
key -> value : 6 -> 6
key -> value : 3 -> 3
key -> value : 4 -> 4
key -> value : 5 -> 5
key -> value : 7 -> 7
key -> value : 9 -> 9
key -> value : 0 -> 0
key -> value : 1 -> 1

slice与map操作（slice of map）

package main
import (
    "fmt"
)
func main() {
    items := make([]map[int]int, 5)
    for i := 0; i < 5; i++ {
        items[i] = make(map[int]int)
    }
    items[0][0] = 0
    items[1][2] = 3
    fmt.Println(items)
}

输出结果：

[map[0:0] map[2:3] map[] map[] map[]]

map排序：

先获取所有key，把key进行排序，再按照排序好的key，进行遍历。

package main
import (
    "fmt"
    "sort"
)
func main() {
    m := map[string]string{"q": "q", "w": "w", "e": "e", "r": "r", "t": "t", "y": "y"}
    var slice []string
    for k, _ := range m {
        slice = append(slice, k)
    }
    fmt.Printf("clise string is : %v\n", slice)
    sort.Strings(slice[:])
    fmt.Printf("sorted slice string is : %v\n", slice)
    for _, v := range slice {
        fmt.Println(m[v])
    }
}

输出结果：

clise string is : [e r t y q w]
sorted slice string is : [e q r t w y]
e
q
r
t
w
y

map反转：
初始化另外一个map，把key、value互换即可.

package main
import (
    "fmt"
)
func main() {
    m := map[int]string{1: "x", 2: "w", 3: "e", 4: "r", 5: "t", 6: "y"}
    fmt.Println(m)
    m_rev := make(map[string]int)
    for k, v := range m {
        m_rev[v] = k
    }
    fmt.Println(m_rev)
}

输出结果：

map[3:e 4:r 5:t 6:y 1:x 2:w]
map[r:4 t:5 y:6 x:1 w:2 e:3]

从 map 中取回的是一个 value 临时复制品，对其成员的修改是没有任何意义的。

package main
import (
    "fmt"
)
func main() {
    m := map[int]string{1: "x", 2: "w"}
    fmt.Println(m)
    for k, v := range m {
        m[k] = v + v   //修改map的值
        v = v + "copy" //临时复制品，修改无效
    }
    fmt.Println(m)
}

输出结果：

容器和结构体（map and struct）

语法比较：
map[type]struct
map[type]*struct

package main
import "fmt"
func main() {
    type user struct{ name string }
    /*
       当 map 因扩张而重新哈希时，各键值项存储位置都会发生改变。
       因此，map 被设计成 not addressable。
       类似 m[1].name 这种期望透过原 value 指针修改成员的行为自然会被禁 。
    */
    m := map[int]user{ //
        1: {"user1"},
    }
    // m[1].name = "Tom"
    // ./main.go:16:12: cannot assign to struct field m[1].name in map
    fmt.Println(m)
    // 正确做法是完整替换 value 或使用指针。
    u := m[1]
    u.name = "Tom"
    m[1] = u // 替换 value。
    m2 := map[int]*user{
        1: &user{"user1"},
    }
    m2[1].name = "Jack" // 返回的是指针复制品。透过指针修改原对象是允许的。
    fmt.Println(m2)
}

输出结果：

map[1:{user1}]
map[1:0xc42000e1e0]

可以在迭代时安全删除键值。但如果期间有新增操作，那么就不知道会有什么意外了。

package main
import "fmt"
func main() {
    for i := 0; i < 5; i++ {
        m := map[int]string{
            0: "a", 1: "a", 2: "a", 3: "a", 4: "a",
            5: "a", 6: "a", 7: "a", 8: "a", 9: "a",
        }
        for k := range m {
            m[k+k] = "x"
            delete(m, k)
        }
        fmt.Println(m)
    }
}

输出: 
//每次输出都会变化

map[36:x 28:x 32:x 2:x 8:x 10:x 12:x]
map[12:x 6:x 16:x 28:x 4:x 10:x 72:x]
map[12:x 14:x 16:x 18:x 20:x]
map[18:x 10:x 14:x 4:x 6:x 16:x 24:x]
map[12:x 16:x 4:x 40:x 14:x 18:x]