比较熟悉 Python 的对于字典肯定不会陌生，在 Go 中 map 就是 Python 中字典的概念，它的基本格式是
map[keyType]valueType 。map 的读取和设置和 slice 比较相似，只不过 map 中是通过 key 操作，而 slice
是通过 index 操作，index 只能是 int 类型，map 的 key 可以是 int 、string等类型。
字典的赋值方式
1.先声明再初始化最后赋值
package main
import "fmt"
func main() {
// 先声明一个字典,key类型为string value类型为string
var m1 map[string]string
// 只声明不赋值的map,零值为nil,此时不能给map赋值
if m1 == nil {
// 使用 make 函数对map初始化
m1 = make(map[string]string)
}
if m1 != nil {
// 输出 map[]
fmt.Println(m1)
// 赋值操作
m1["name"] = "xiaoming"
fmt.Println(m1)
}
}
输出结果
[root@VM_81_181_centos golang]# go run map01.go
map[]
map[name:xiaoming]
2.使用 make 初始化之后再赋值
package main
import "fmt"
func main() {
// 使用 make 直接初始化
m1 := make(map[string]int)
m1["age"] = 23
fmt.Println(m1)
}
输出结果
[root@VM_81_181_centos golang]# go run map02.go
map[age:23]
3.直接初始化赋值
package main
import "fmt"
func main() {
m1 := map[string]string{
"name":"xiaoming",
"hobby":"football",
}
fmt.Println(m1)
}
输出结果
[root@VM_81_181_centos golang]# go run map03.go
map[name:xiaoming hobby:football]
字典的遍历
字典遍历提供了两种方式，一种是需要携带 value，另一种是只需要 key，需要使用 range 关键字
package main
import "fmt"
func main() {
fruits := map[string]int{
"apple":2,
"banana":5,
"orange":8,
}
// 需要携带 value
for name,score := range fruits{
fmt.Println(name, score)
}
// 只需要key
for name := range fruits{
fmt.Println(name)
}
}
输出结果
[root@VM_81_181_centos golang]# go run map04.go
apple 2
banana 5
orange 8
#########
apple
banana
orange
在 Go 中没有提供类似 keys() 和 values() 这样的方法，如果我们想获取 key 和 value 的列表需要自己循环
package main
import "fmt"
func main() {
fruits := map[string]int{
"apple":2,
"banana":5,
"orange":8,
}
names := make([]string,0,len(fruits))
scores := make([]int,0,len(fruits))
for name,score := range fruits{
names = append(names,name)
scores = append(scores,score)
}
fmt.Println(names,scores)
}
输出结果
[root@VM_81_181_centos golang]# go run map05.go
[apple banana orange] [2 5 8]
字典的读写
package main
import "fmt"
func main() {
fruits := map[string]int {
"apple": 2,
"banana": 5,
"orange": 8,
}
// 读
fmt.Println(fruits["apple"])
// 增加或修改
fruits["pear"] = 9
fmt.Println(fruits)
// 删除
delete(fruits, "pear")
fmt.Println(fruits)
}
输出结果
[root@VM_81_181_centos golang]# go run map08.go
2
map[banana:5 orange:8 pear:9 apple:2]
map[apple:2 banana:5 orange:8]
字典的多态返回值
在上面的实例中已经可以知道通过 val1 = map1[key1] 的方法获取 key1 对应的值 val1。如果 map 中不存在 key1，
val1 就是一个值类型的空值。那么，此时就会出现一个问题 key1 是不存在还是 key1 对应的值就是空值？
下面介绍一种方式判断 map 中 key 是否存在： val1 ， isPresent = map1[key1] ，isPresent 返回一个 bool 值：如果
key1 存在，val1 就是 key1 对应的 value 值，并且 isPresent 为 true；如果 key1 不存在，val1 就是一个空值，并且 isPresent
返回 false。
如果只是想判断某个 key 是否存在而不关心它对应的值到底是多少，可以这样做：
_,ok = map1[key1]// 如果 key1 存在，ok == true 否在 ok == false
或者和 if 混合使用
if _,ok := map1[key1];ok {
//....
}
从 map1 中删除 key1，直接 delete(map1,key1)，如果 key1 不存在，该操作也不会报错
package main
import "fmt"
func main() {
map1 := make(map[string]int)
map1["New Delhi"] = 55
map1["Beijing"] = 20
map1["Washington"] = 25
value,isPresent := map1["Beijing"]
if isPresent {
fmt.Printf("The value of \"Beijin\" in map1 is: %d\n", value)
} else {
fmt.Printf("map1 does not contain Beijing")
}
// 删除元素
delete(map1,"Washington")
value,isPresent = map1["Washington"]
if isPresent {
fmt.Printf("The value of \"Washington\" in map1 is: %d\n", value)
} else {
fmt.Println("map1 does not contain Washington")
}
}
输出结果
[root@VM_81_181_centos golang]# go run map09.go
The value of "Beijin" in map1 is: 20
map1 does not contain Washington
[root@VM_81_181_centos golang]#
字典的排序
字典默认是无序的，如果想要为 map 排序，需要将 key (或者value) 拷贝至一个切片中，再对切片排序，然后可以使用
切片的 for-range 方法打印所有的 key 和 value
package main import (
"fmt"
"sort"
) func main() {
barVal := map[string]int{
"alpha": 34,
"bravo": 56,
"charlie": 23,
"delta": 87,
"echo": 56,
"foxtrot": 12,
"golf": 34,
"hotel": 16,
"indio": 87,
"juliet": 65,
"kili": 43,
"lima": 98,
}
fmt.Println("unsorted:")
for key,value := range barVal{
fmt.Printf("Key: %v, Value: %v / ", key, value)
} // 创建切片
keys := make([]string,len(barVal))
i := 0
for k,_ := range barVal{
keys[i] = k
i++
} sort.Strings(keys) fmt.Println("sorted")
for _,k := range keys{
fmt.Printf("Key: %v, Value: %v / ", k, barVal[k])
}
}
输出结果
unsorted:
Key: kili, Value: 43 / Key: alpha, Value: 34 / Key: foxtrot, Value: 12 / Key: hotel, Value: 16 / Key: echo, Value: 56 / Key: golf, Value: 34 / Key: indio, Value: 87 / Key: juliet, Value: 65 / Key: lima,
Value: 98 / Key: bravo, Value: 56 / Key: charlie, Value: 23 / Key: delta, Value: 87 / sorted
Key: alpha, Value: 34 / Key: bravo, Value: 56 / Key: charlie, Value: 23 / Key: delta, Value: 87 / Key: echo, Value: 56 / Key: foxtrot, Value: 12 / Key: golf, Value: 34 / Key: hotel, Value: 16 / Key: indi
o, Value: 87 / Key: juliet, Value: 65 / Key: kili, Value: 43 / Key: lima, Value: 98 /
字典的键值对调
这里的键值对调是指调换 key 和 value ，首先能想到的方法就是构造另一个以原 map 的 key 作为 value，以原 map
的 value 作为 key 的 map，然后使用 for-range 遍历原 map 并导入新 map
package main
import "fmt"
func main() {
originMap := map[string]int{
"a":0,
"b":0,
"c":2,
}
fmt.Println(originMap)
newMap := make(map[int]string)
for key,value := range originMap{
newMap[value] = key
}
fmt.Println(newMap)
}
输出结果
map[a:0 b:0 c:2]
map[2:c 0:b]
看输出结果，会发现上面的代码有一个大问题，如果原 map 的 value 不唯一，就会导致新 map 无法完全包含原 map 的
键值对，对于这个问题我们可以使用多值 map的方法解决：map[int][]string，用切片作为 map 的值
package main
import "fmt"
func main() {
originMap := map[string]int{
"a":0,
"b":0,
"c":2,
}
fmt.Println(originMap)
newMap := make(map[int][]string)
for key,value := range originMap{
newMap[value] = append(newMap[value],key)
}
fmt.Println(newMap)
}
输出结果
map[b:0 c:2 a:0]
map[0:[a b] 2:[c]]