3.10 Go Map哈希表

3.10 Go Map哈希表

map是key-value类型数据结构，读作（哈希表、字典），是一堆未排序的键值对集合。

map是引用类型，使用make函数或者初始化表达式创建。

map的key必须是支持相等运算符==、!=的类型，如int、bool、channel、string、pointer、array、sruct、interface。

通常map的key是int、string

map的value可以是任意类型，没有限制，通常是int、float、string、struct

2. map声明

package main

import "fmt"

func main() {
    /*
        map声明语法
        var 变量名  map[keytype]valuetype

        var m1 map[string]string
        var m2 map[int]string
        var m3 map[int]map[string]string//map的value又是map

        注意map声明不会分配内存，必须make初始化才可以使用
    */

    //声明map方式一
    //make函数可以合理申请一大块内存，避免后续扩张时性能问题
    var m1 map[string]string
    //标注map的初始容量为10
    m1 = make(map[string]string, 10)
    m1["一号"] = "大狗子"
    m1["二号"] = "二狗子"
    fmt.Println(m1)

    //声明方式二
    m2 := make(map[string]string)
    m2["男"] = "小黑"
    m2["女"] = "小女"
    fmt.Println(m2)

    //声明方式三
    m3 := map[string]string{
        "坦克": "德玛西亚",
        "射手": "伊泽瑞尔",
        "辅助": "星女",
    }
    m3["打野"] = "赵信"
    fmt.Println(m3)
}

3. map增删改查

访问不存在的键值，默认返回零值，不会引发错误。

推荐使用ok-idiom模式，如： val, ok := m1["k4"]

package main

import "fmt"

func main() {
    m1 := map[string]string{"k1": "v1", "k2": "v2"}
    fmt.Printf("m1值：%v\n", m1)

    //map插入值
    m1["k3"] = "v3"
    fmt.Printf("插入后m1值：%v\n", m1)

    //map修改值
    m1["k1"] = "v11111"
    fmt.Printf("修改k1值后：%v\n", m1)

    //map查找值
    val, ok := m1["k4"]
    if ok {
        fmt.Printf("k4的值是：%v\n", val)
    }

    //长度: 获取键值对数量
    m1Len := len(m1)
    fmt.Printf("m1长度：%v\n", m1Len)

    //判断key是否存在
    if val, ok := m1["k4"]; !ok {
        fmt.Printf("此key不存在\n")
    } else {
        fmt.Printf("此key的值：%v\n", val)
    }

    //删除map的key，如key不存在，delete不进行操作
    //delete函数按指定的键，将元素从映射中删除
    //一次性删除所有key可以遍历下，逐个删除
    //也可以重新make新map，让原本map被gc回收
    if _, ok := m1["k3"]; ok {
        delete(m1, "k3")
        fmt.Printf("已删除m1中的k3\n")
    } else {
        fmt.Printf("无法删除，此key不存在")
    }
    fmt.Printf("此时m1的值：%v\n", m1)
}

4. map遍历

使用for-range结构遍历

package main

import "fmt"

func main() {
    //循环性生成10个key的map
    m1 := make(map[int]int)
    for i := 0; i < 10; i++ {
        m1[i] = i + 1
        fmt.Printf("m1的key：%v value:%v\n", i, m1[i])
    }
    fmt.Println(m1)
fmt.Println("--分割线--")
    //循环遍历map的值
    for k, v := range m1 {
        fmt.Printf("m1的key：%v m1的值%v\n", k, v)
    }
}

遍历复杂map

map的value又是map

package main

import "fmt"

func main() {
    //make初始化第一层map，分配内存
    stuMap := make(map[string]map[string]string)
    //第二层map初始化
    stuMap["stu01"] = make(map[string]string)
    stuMap["stu01"]["名字"] = "大狗子"
    stuMap["stu01"]["年纪"] = "18"

    //切记，map必须make后方可使用
    stuMap["stu02"] = make(map[string]string)
    stuMap["stu02"]["名字"] = "二麻子"
    stuMap["stu02"]["年纪"] = "17"

    fmt.Println(stuMap)

    //取出所有学生的信息
    for k, v := range stuMap {
        fmt.Printf("k值是学生：%v  v值是学生信息：%v\n", k, v)
        //k1是键，v1是值
        for k1, v1 := range v {
            fmt.Printf("\tk1：%v v1：%v\n", k1, v1)
        }
        fmt.Println()
    }
}

5. map切片

声明一个切片(slice)，并且这个切片的类型是map，这就被称作slice of map，map切片，这样map的个数就可以动态变化了。

package main

import "fmt"

func main() {
    //声明map切片，
    // 默认值        [map[] map[] map[] map[] map[]]
    sliceMap := make([]map[string]string, 5)
    for i := 0; i < 5; i++ {
        //map必须初始化再用,遍历初始化
        sliceMap[i] = make(map[string]string)
    }
    sliceMap[0]["名字"] = "张飞"
    sliceMap[1]["性别"] = "不男不女"
    sliceMap[2]["体重"] = "三百斤"
    fmt.Println(sliceMap)
    fmt.Printf("容量：%v，长度：%v\n", cap(sliceMap), len(sliceMap))

    //动态扩容map切片，用append函数
    newSliceMap := map[string]string{
        "姓名": "狗子",
        "爱好": "吃包子",
    }
    //append函数进行切片扩容，动态增加
    sliceMap = append(sliceMap, newSliceMap)
    fmt.Println(sliceMap)
    fmt.Printf("容量：%v，长度：%v\n", cap(sliceMap), len(sliceMap))
}

6. map排序

map默认是无序的，每次遍历都是不同的结果

package main

import "fmt"

func main() {
    //无须的map
    m1 := make(map[int]int)
    for i := 0; i < 10; i++ {
        m1[i] = i + 1
    }
    //遍历结果无序
    for k, v := range m1 {
        fmt.Println(k, v)
    }
}

通过索引排序取值

package main

import "fmt"

func main() {
    m1 := map[int]string{
        1: "红孩儿",
        2: "孙悟空",
        3: "银角大王",
        4: "金角大王",
    }
    //无序
    // for k, v := range m1 {
    //     fmt.Println(k, v)
    // }
    //通过索引，有序取值
    for i := 1; i <= len(m1); i++ {
        fmt.Println(i, m1[i])
    }
}

sort包排序

golang没有针对map的key排序的方法。

必须先对key排序，然后根据key值就可以输出排序后的结果

调用sort包函数进行排序

sort.Strings

sort.Ints

package main

import (
    "fmt"
    "sort"
)

func main() {
    //定义一个m map变量
    m := map[string]string{"q": "q", "w": "w", "e": "e", "r": "r", "t": "t", "y": "y"}
    fmt.Println(m)
    //定义一个 string类型切片
    var slice []string
    //循环遍历map，取出所有的key和value
    for k, _ := range m {
        //循环将key添加到切片中
        slice = append(slice, k)
    }
    fmt.Printf("切片slice值 : %v\n", slice)
    //调用排序包，对切片进行排序，按照字母顺序排序
    sort.Strings(slice[:])
    fmt.Printf("排序后 切片slice值 : %v\n", slice)
    for _, v := range slice {
        fmt.Printf("排序后 m[%v]=%v\n", v, m[v])
    }
}

7. map使用细节

1）map是引用类型，遵循引用类型传递的机制，在函数接收map参数，对map修改是直接操作原本的map。

package main

import "fmt"

func modify(m map[string]string) {
    m["名字"] = "狗子"

}
func main() {
    //map是引用类型，遵循引用引用类型传递
    m1 := make(map[string]string)
    m1["名字"] = "傻子"
    m1["年纪"] = "十八"
    fmt.Println(m1)
    modify(m1) //直接对m1进行修改，说明是引用类型
    fmt.Println(m1)
}

2）map可以自动扩容，动态增长。

package main

import "fmt"

func main() {
    //初始化m1，限制容量3
    m1 := make(map[int]int, 3)
    for i := 0; i < 10; i++ {
        m1[i] = i + i
    }
    fmt.Println(m1)
    fmt.Printf("m1元素个数：%v", len(m1))
}

3）map的value也可以是struct类型，适合更复杂的数据

package main

import "fmt"

type Stu struct {
    Name    string
    Age     int
    Address string
}

func main() {
    //map的value可以为更复杂的struct结构体类型
    //map的key是学号
    //map的value是结构体{姓名、年纪、住址}
    students := make(map[int]Stu, 10)
    //初始化结构体,不需要填写key，顺序value即可
    stu1 := Stu{"alex", 1000, "沙河"}
    stu2 := Stu{"武沛奇", 999, "于辛庄"}
    students[1] = stu1
    students[2] = stu2
    fmt.Println(students)
    //遍历map，取出学生信息
    for k, v := range students {
        fmt.Printf("学生编号%v\n", k)
        fmt.Printf("学生姓名%v\n", v.Name)
        fmt.Printf("学生年纪%v\n", v.Age)
        fmt.Printf("学生住址%v\n", v.Address)
        fmt.Println("--------")
    }
}

4）函数len返回键值对数量，cap不适用map类型。

5）因内存访问安全和哈希算法等因素，字典设计是not addressable，不得直接修改value成员(struct或array)

6）mymap["age"]+=1此代码报错

7）mymap["age"]++ 相当于mymap["age"]=mymap["age"]+1 ，此代码正确，mymap["age"]返回的是指针