Go语言入门5－map映射

1. 类似其它语言中的哈希表或者字典，以key-value形式存储数据
2. Key必须是支持==或!=比较运算的类型，不可以是函数、map或slice
3. Map查找比线性搜索快很多，但比使用索引访问数据的类型慢100倍
4. Map使用make()创建，支持 := 这种简写方式

func main() {
m := make(map[int]string)	//int是健的类型 string是值的类型
m[1] = "ok"
fmt.Println(m) 	//map[1:ok]
a := m[1]
fmt.Println(a)
delete(m, 1)	//ok
fmt.Println(m) 	//map[]
}

通过双赋值检测某个键是否存在：elem, ok := m[key]
若 key 在 m 中，ok 为 true ；否则，ok 为 false。
若 key 不在映射中，那么 elem 是该映射元素类型的零值。
同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。

func main() {
m := make(map[string]int)

m["Answer"] = 42
fmt.Println("The value:", m["Answer"])	//The value: 42

delete(m, "Answer")
fmt.Println("The value:", m["Answer"])	//The value: 0

v, ok := m["Answer"]
fmt.Println("The value:", v, "Present?", ok)	//The value: 0 Present? false
}

当有多个map嵌套map的时候，每一级的map都要单独的初始化，否则运行时会报错。

//返回值为两个时 第二个参数为bool 类型 可以判断第二个参数来判断第一个参数是否正确
func main() {
m := make(map[int]map[int]string)
a, ok := m[2][1]
fmt.Println(a, ok) // false
if !ok {
m[2] = make(map[int]string)
}
m[2][1] = "good"
a, ok = m[2][1]
fmt.Println(a, ok)good true
}

遍历（v只是一个拷贝，对v的任何操作都不会影响本身的slice）

func main() {
sm := make([]map[int]string, 5)
for _, v := range sm {
v = make(map[int]string, 1)
v[1] = "ok"
fmt.Println(v)
}
fmt.Println(sm)
}

结果：

map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
[map[] map[] map[] map[] map[]]

如果想改变本身的slice，则需要用i，例：

func main() {
sm := make([]map[int]string, 5)
for i := range sm {
sm[i] = make(map[int]string, 1)
sm[i][1] = "ok"
fmt.Println(sm[i]<
20000
/span>)
}
fmt.Println(sm)
}

结果

map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
[map[1:ok] map[1:ok] map[1:ok] map[1:ok] map[1:ok]]

循环map是无序的,不能够直接排序。

func main() {
m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "f"}
s := make([]int, len(m))
i := 0
for k, _ := range m {
s[i] = k
i++
}
fmt.Println(s)
}

每次执行后的结果都不相同，这也就证明了map是无序的

➜ gogogo go run demo.go
[5 1 2 3 4]
➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo go run demo.go
[3 4 5 1 2]
➜ gogogo

下面我们通过导入sort包间接的让map有序

func main() {
m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "f"}
s := make([]int, len(m))
i := 0
for k, _ := range m {
s[i] = k
i++
}
sort.Ints(s)
fmt.Println(s) //[1 2 3 4 5]
}

每次执行后的结果相同了，这就间接实现了map的有序

➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo

demo：尝试将类型为map[int]string的键和值进行交换，变成类型map[string]int

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

结果

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