谈一谈Go的Map的使用用法

写法一：

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

输出

97

写法二：

package mainimport "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]Goage

写法三：

初始化+赋值package mainimport "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]Go8

遍历map方法一

package mainimport "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的值为languageone的值为gotwo的值为isthree的值为afour的值为programing

遍历map方法二

package mainimport "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 mainimport "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中则返回trueif _, is_exist := m1["six"]; is_exist {fmt.Println("m1[\"six\"]存在在m1里。")} else {fmt.Println("m1[\"six\"]不存在m1里。")}}

输出：

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

delete函数的使用

package mainimport "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 和其对应的 keyfmt.Println(a)fmt.Println(m1) //成功删除m1["one"]}

输出：

gomap[two:is three:a four:programing fine:language]

多返回值

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

输出：

true 1111

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

输出：

false

多返回值的使用

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

输出：

falsetrue GOOD

map的迭代

package mainimport "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 mainimport "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 mainimport ("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] = ki++}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 mainimport ("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]