谈一谈Go的Map的使用用法

谁践踏了优雅 2022-06-02 23:40 264阅读 0赞

写法一：

package main
    
    import "fmt"
    
    func main() {
    var m1 map[int]int // 先声明map
    m1 = make(map[int]int) //再使用make函数创建一个非nil的map，nil map不能赋值
    m1['a'] = 'a' // 最后给已声明的map赋值
    // m1["b"] = "b" //该写法不对，会报错 cannot convert "b" to type int
    fmt.Println(m1['a'])
    }

输出

写法二：

package main
    
    import "fmt"
    
    func main() {
    //直接创建
    m1 := make(map[string]string)
    // m1 := map[string]string{}//或者这样写也可以
    //然后赋值
    m1["name"] = "Go"
    m1["age"] = "age"
    fmt.Println(m1)
    fmt.Println(m1["name"])
    fmt.Println(m1["age"])
    }

输出：

map[name:Go age:age]
    Go
    age

写法三：

初始化+赋值
    package main
    
    import "fmt"
    
    func main() {
    m1 := map[string]string{
    "name": "Go",
    "age": "8"} //注意该花括号不能独自写一行，会报错syntax error: unexpected newline, expecting comma or }
    fmt.Println(m1)
    fmt.Println(m1["name"])
    fmt.Println(m1["age"])
    }

输出：

map[name:Go age:8]
    Go
    8

遍历map方法一

package main
    
    import "fmt"
    
    func main() {
    //遍历map
    //Map是一种无序的键值对的集合。Map最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值。
    //Map是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
    // 使用key输出map的值
    m1 := map[string]string{
    "one": "go",
    "two": "is",
    "three": "a",
    "four": "programing",
    "fine": "language"}
    for k := range m1 {
    fmt.Println(k + "的值为" + m1[k])
    }
    }

输出：

fine的值为language
    one的值为go
    two的值为is
    three的值为a
    four的值为programing

遍历map方法二

package main
    
    import "fmt"
    
    func main() {
    //遍历map
    //Map是一种无序的键值对的集合。Map最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值。
    //Map是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
    //直接输出map的key和值
    m1 := map[string]string{
    "one": "go",
    "two": "is",
    "three": "a",
    "four": "programing",
    "fine": "language"}
    for k, v := range m1 {
    fmt.Println("键名为：" + k + ", " + "键值为：" + v)
    }
    }

输出：

//因为是无序的，每次运行输出的结果都不一样
      键名为：fine, 键值为：language
      键名为：one, 键值为：go
      键名为：two, 键值为：is
      键名为：three, 键值为：a
      键名为：four, 键值为：programing
    
      键名为：two, 键值为：is
      键名为：three, 键值为：a
      键名为：four, 键值为：programing
      键名为：fine, 键值为：language
      键名为：one, 键值为：go

查找键值是否存在

package main
    
    import "fmt"
    
    func main() {
    //遍历map
    //Map是一种无序的键值对的集合。Map最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值。
    //Map是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
    m1 := map[string]string{
    "one": "go",
    "two": "is",
    "three": "a",
    "four": "programing",
    "fine": "language"}
     //查看元素是否在map中,变量 is_exist 会返回true或者false，当查询的key在map中则返回true
    if _, is_exist := m1["six"]; is_exist {
    fmt.Println("m1[\"six\"]存在在m1里。")
    } else {
    fmt.Println("m1[\"six\"]不存在m1里。")
    }
    }

输出：

m1["six"]不存在m1里。

delete函数的使用

package main
    
    import "fmt"
    
    func main() {
    //遍历map
    //Map是一种无序的键值对的集合。Map最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值。
    //Map是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
    //直接输出map的key和值
    m1 := map[string]string{
    "one": "go",
    "two": "is",
    "three": "a",
    "four": "programing",
    "fine": "language"}
    a := m1["one"]
    delete(m1, "one") //delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key
    fmt.Println(a)
    fmt.Println(m1) //成功删除m1["one"]
    }

输出：

go
    map[two:is three:a four:programing fine:language]

多返回值

package main
    
    import "fmt"
    
    func main() {
    var m1 map[int]string
    m1 = make(map[int]string)
    m1[2] = "1111"
    a, ok := m1[2] //多返回值，当m1[2][1]有值则a就是其值，ok为true，否则为false
    fmt.Println(ok, a) 
    }

输出：

true 1111

package main
    
    import "fmt"
    
    func main() {
    var m1 map[int]string
    m1 = make(map[int]string)
    m1[2] = "1111"
    a, ok := m1[1] //多返回值，当m1[2][1]有值则a就是其值，ok为true，否则为false
    fmt.Println(ok, a) 
    }

输出：

false

多返回值的使用

package main
    
    import "fmt"
    
    func main() {
    //多重map
    var m1 map[int]map[int]string
    m1 = make(map[int]map[int]string)
    a, ok := m1[2][1] //多返回值，当m1[2][1]有值则a就是其值，否则多返回了个布尔值ok
    fmt.Println(ok, a)
    if !ok {
    m1[2] = make(map[int]string) //不存在就要初始化
    }
    m1[2][1] = "GOOD"
    a, ok = m1[2][1]
    fmt.Println(ok, a)
    }

输出：

false
    true GOOD

map的迭代

package main
    
    import "fmt"
    
    func main() {
    sm := make([]map[int]string, 5) //创建一个map类型的slice
    //注意的是v只是sm值得拷贝，并不能修改sm的值
    for _, v := range sm {
    v = make(map[int]string, 1)
    v[1] = "GO"
    fmt.Println(v)
    }
    //所以这里打出来的还是空的map[]
    fmt.Println(sm)
    }

输出：

map[1:GO]
      map[1:GO]
      map[1:GO]
      map[1:GO]
      map[1:GO]
      [map[] map[] map[] map[] map[]]

package main
    
    import "fmt"
    
    func main() {
    sm := make([]map[int]string, 5) //创建一个map类型的slice
    //想要修改sm的值，应该通过sm[i]就可以修改
    for i := range sm {
    sm[i] = make(map[int]string, 1)
    sm[i][1] = "GO"
    fmt.Println(sm[i])
    }
    //sm值已经改变了
    fmt.Println(sm)
    }

输出：

map[1:GO]
      map[1:GO]
      map[1:GO]
      map[1:GO]
      map[1:GO]
      [map[1:GO] map[1:GO] map[1:GO] map[1:GO] map[1:GO]]

如何对无序的map进行间接排序？

package main
    
    import (
    "fmt"
    "sort"
    )
    
    func main() {
    //通过配合slice来对map进行间接排序
    m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}
    s := make([]int, len(m))
    i := 0
    //对map的排序其实就是对key的排序
    for k, _ := range m {
    s[i] = k
    i++
    }
    sort.Ints(s) //对int型进行排序，可知slice是引用类型，因为排序完没有返回值，而只是把s传进去排序
    fmt.Println(s)
    for i := range s {
    fmt.Println("m[\"", i, "\"] + 键值为："+m[i+1])
    }
    }

输出：

[1 2 3 4 5]
      m[" 0 "] + 键值为：a
      m[" 1 "] + 键值为：b
      m[" 2 "] + 键值为：c
      m[" 3 "] + 键值为：d
      m[" 4 "] + 键值为：e

Go里面如何实现key和value对调？

package main
    
    import (
    "fmt"
    )
    
    func main() {
    m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}
    m2 := map[string]int{}
    fmt.Println(m)
    
    for k, v := range m {
    m2[v] = k
    }
    fmt.Println(m2)
    }

输出：

map[1:a 2:b 3:c 4:d 5:e]
      map[e:5 a:1 b:2 c:3 d:4]