谈一谈Go的Map的使用用法

写法一：

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'])
}

输出

97

写法二：

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]