Go 字典(Map)

比较熟悉 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]]
上一篇:delphi’线程新技术 并行计算


下一篇:Linux下解决apache 报 403 forbidden 错