初始化

package main

import "fmt"

//22
func main() {
    /*
    map:映射，是一种专门用于存储键值对的集合，属于引用类型

    存储特点：
        A:存储的是无序的键值对
        B：键不能重复，并且和value值一一对应
            map中的key不能重复，如果重复，那么新的value会覆盖掉原来的，不会报错

        语法结构：
            1. 创建map
                var map map[key类型]value类型
                    nil map，无法直接使用

                var map = make(map[key类型]value类型)

                var map = map[key类型]value类型{key:value,key:value...}

        int：0
        float：0.0 0
        string：""
        array：

        slice：nil
        map：nil
    */
    //创建
    var map1 map[int]string //没有初始化，nil
    var map2 = make(map[int]string)
    var map3 = map[string]int{"go":98, "python":97}
    fmt.Println(map1)
    fmt.Println(map2)
    fmt.Println(map3)

    fmt.Println(map1 == nil)
    fmt.Println(map2 == nil)
    fmt.Println(map3 == nil)

    if map1 == nil {
        map1 = make(map[int]string)
        fmt.Println(map1 == nil)
    }

}

map的使用

//存储键值对
    map1[1] = "hello"
    map1[2] = "world"
    map1[3] = "haha"
    map1[4] = "zhangsan"

    //获取数据，根据key获取键值对
    //多运行几次，结果无序
    fmt.Println(map1)

    fmt.Println(map1[4]) //key不存在得到的是类型的默认值

    //如何判断是不存在还是就是设定的默认值
    v1,ok := map1[40]
    if ok {
        fmt.Println("对应数据：",v1)
    }else {
        fmt.Println("不存在，获取为零值：",v1)
    }

    //修改数据
    fmt.Println(map1)
    map1[3] = "hehe"
    fmt.Println(map1)

    //删除数据 key不存在无影响
    delete(map1, 3)
    fmt.Println(map1)

    //长度
    fmt.Println(len(map1))

map的遍历

/*
    遍历：for range
        数组，切片：index、value
        map：key，value

    */

    for k,v := range map1 {
        fmt.Println(k,v) //无序
    }

    //如何有序？
    fmt.Println("有序")

    //但是key无序不行了
    for i := 1; i < len(map1); i++ {
        fmt.Println(i, "---->", map1[i])
    }

    /*
    获取所有key，做切片/数组
    进行排序
    遍历key
    */
    keys := make([]int, 0, len(map1))

    for k,_ := range map1 {
        keys = append(keys, k)
    }
    fmt.Println(keys)

    //排序 sort包下的排序方法
    sort.Ints(keys)
    fmt.Println(keys)

    for _,key := range keys {
        fmt.Println(key,map1[key])
    }

Map结合Slice

/*
    map结合slice
        1. 创建map用于存储人的信息

        2. 每个map存储一个人的信息

        3. 将这些map存入到slice中

        4. 打印遍历输出

    */

    //1.
    map5 := make(map[string]string)
    map5["name"] = "王二狗"
    map5["age"] = "18"
    map5["sex"] = "男"
    map5["address"] = "召唤师峡谷"
    fmt.Println(map5)

    //第二个人只能再创建map
    map6 := make(map[string]string)
    map6["name"] = "小花"
    map6["age"] = "18"
    map6["sex"] = "女"
    map6["address"] = "召唤师峡谷"
    fmt.Println(map6)

    //第三个人
    map7 := map[string]string{"name":"st","age":"22","sex":"男","address":"长春"}
    fmt.Println(map7)

    //2.
    s1 := make([]map[string]string, 0, 3)
    s1 = append(s1, map5)
    s1 = append(s1, map6)
    s1 = append(s1, map7)

    //遍历
    for i,val := range s1 {
        fmt.Printf("第%d个人的信息是：\n",i)
        fmt.Printf("\t姓名：%s\n", val["name"])
        fmt.Printf("\t年龄：%s\n", val["age"])
        fmt.Printf("\t性别：%s\n", val["sex"])
        fmt.Printf("\t地址：%s\n", val["address"])
    }

map是引用类型数据

/*
    map是引用类型
    */

    map10 := make(map[int]string)
    map11 := make(map[string]float64)
    fmt.Printf("%T\n", map10) //map[int]string
    fmt.Printf("%T\n", map11) //map[string]float64

    map13 := make(map[string]map[string]string)
    m1 := make(map[string]string)
    m1["name"] = "王二狗"

    m2 := make(map[string]string)
    m2["name"] = "张三"

    map13["hr"] = m1
    map13["开发"] = m2
    fmt.Printf("%T\n", map13)
    fmt.Println(map13) //map[hr:map[name:王二狗] 开发:map[name:张三]]

    fmt.Println("-----------")
    map14 := make(map[string]string)
    map14["st"] = "好看"
    fmt.Println(map14)

    map15 := map14
    fmt.Println(map15)

    map14["st"] = "不好看"
    fmt.Println(map14)
    fmt.Println(map15)