GoLang基礎數據類型--->字典（map）詳解

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑

版權聲明：原創作品，謝絕轉載！否則將追究法律責任。

 

 　　可能大家剛剛接觸Golang的小伙伴都會跟我一樣，這個map是干嘛的，是函數嗎？學過python的小伙伴可能會想到map這個函數。其實它就是Golang中的字典。下面跟我一起看看它的特性吧。map 也就是 Python 中字典的概念，它的格式為“map[keyType]valueType”。 map 的讀取和設置也類似 slice 一樣，通過 key 來操作，只是 slice 的index 只能是｀int｀類型，而 map 多了很多類型，可以是 int ，可以是 string及所有完全定義了 == 與 != 操作的類型。

 

一.map的賦值方式

1.先的聲明再初始化最后賦值

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
"fmt"
"reflect"
)

func main() {
var yinzhengjie map[string]string //先聲明一個字典（map）名字叫做yinzhengjie。其key所對應的數據類型是“string”[字符串]，value所對應的數據類型也是“string”。
fmt.Printf("判斷yinzhengjie字典是否為空:【%v】\n",yinzhengjie == nil) //聲明的字典，默認為空，需要用make進行初始化操作(map是引用類型，未初始化的是指向nil，初始化了以后應該就有自己的內存空間了，所以不是nil。)所以返回值為空。
fmt.Printf("第一次查看yinzhengjie字典的值：【%v】\n",yinzhengjie)
yinzhengjie = make(map[string]string) //再使用make函數進行初始化創建一個非nil的map，nil map不能賦值,如果直接賦值會報錯：“panic: assignment to entry in nil map”
fmt.Printf("再次判斷yinzhengjie字典是否為空：【%v】\n",yinzhengjie == nil) //你就把它理解為一個指針，沒初始化就是nil，make之后分配內存了,一旦分配了內存地址就不為空了
fmt.Printf("第二次查看yinzhengjie字典的值：【%v】\n",yinzhengjie)
yinzhengjie["name"] = "尹正傑"
fmt.Printf("yinzhengjie字典的類型為：【%v】\n",reflect.TypeOf(yinzhengjie))
fmt.Printf("第三次查看yinzhengjie字典的值：【%v】\n",yinzhengjie)
}

 

#以上代碼執行結果如下：
判斷yinzhengjie字典是否為空:【true】
第一次查看yinzhengjie字典的值：【map[]】
再次判斷yinzhengjie字典是否為空：【false】
第二次查看yinzhengjie字典的值：【map[]】
yinzhengjie字典的類型為：【map[string]string】
第三次查看yinzhengjie字典的值：【map[name:尹正傑]】

 

2.直接make進行初始化之后再賦值

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
yinzhengjie := make(map[string]int) //表示創建一個key為string，value的值為int的數據類型。
yinzhengjie["yzj"] = 25
fmt.Println(yinzhengjie)
}

 

#以上代碼執行結果如下：
map[yzj:25]

3.直接初始化賦值

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
yinzhengjie := map[string]int{
"尹正傑":18,
"餅干":20,
}
fmt.Println(yinzhengjie)
}

 

#以上代碼執行結果如下：
map[尹正傑:18 餅干:20]

 

二.map的增刪改查

1.字典的賦值操作

 
            /*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ 
            package main 
            import "fmt" 
            func main() {
 yinzhengjie := make(map[int]string)
 letter := []string{"a","b","c","d","e","f","g","h"}
 for k,v := range letter{
 yinzhengjie[k] = v
 }
 fmt.Println(yinzhengjie) //注意，字典是無序的喲！
} 
              
            
#以上代碼執行結果如下：
map[7:h 0:a 1:b 2:c 3:d 4:e 5:f 6:g] 
             
           

2.字典的刪除操作

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
yinzhengjie := make(map[int]string)
letter := []string{"a","b","c","d","e","f","g","h"}
for k,v := range letter{
//fmt.Println(k,v)
yinzhengjie[k] = v
}
fmt.Println(yinzhengjie) //注意，字典是無序的喲！

for i:=0;i<4 ;i++ {
delete(yinzhengjie,i) //刪除字典中key所對應的value.1
}
fmt.Println(yinzhengjie)

for k := range yinzhengjie{
delete(yinzhengjie,k) //刪除整個字典的數據
}
fmt.Println(yinzhengjie)
fmt.Println(yinzhengjie==nil) //字典的“殼子”還在，空字典也是有地址的。所以返回值是false！
}

 

#以上代碼執行結果如下：
刪除之前的樣子：【map[5:f 6:g 7:h 0:a 1:b 2:c 3:d 4:e]】
第一次刪除之后的樣子：【map[5:f 6:g 7:h 4:e]】
第二次刪除之后的樣子：【map[]】
字典被清空之后是否為空：【false】

 3.字典的修改操作

 
             
            /*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ 
            package main 
            import "fmt" 
            func main() {
 yinzhengjie := make(map[int]string)
 letter := []string{"a","b","c","d","e","f","g","h"}
 for k,v := range letter{
 //fmt.Println(k,v)
 yinzhengjie[k] = v
 }
 fmt.Printf("修改之前的樣子：【%v】\n",yinzhengjie)
 yzj := yinzhengjie //map是一種引用類型，如果兩個map同時指向一個底層，那么一個改變，另一個也相應的改變。
 yzj[0] = "尹正傑" //修改字典下標所對應的值。
 yzj[1] = "yinzhengjie"
 fmt.Printf("修改之后的樣子：【%v】\n",yinzhengjie)//注意，字典是無序的喲！
} 
              
            #以上代碼執行結果如下：
修改之前的樣子：【map[0:a 1:b 2:c 3:d 4:e 5:f 6:g 7:h]】
修改之后的樣子：【map[7:h 0:尹正傑 1:yinzhengjie 2:c 3:d 4:e 5:f 6:g]】 
           

4.字典的查詢方式

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
yinzhengjie := make(map[int]string)
letter := []string{"a","b","c","d","e","f","g","h"}
for k,v := range letter{
yinzhengjie[k] = v
}
fmt.Println(yinzhengjie) //注意，字典是無序的喲！我下面之所以通過循環遍歷，是因為的確存在哪些key喲！

for i,j := range yinzhengjie{ //遍歷key和value。
fmt.Println("key=",i,"value=",j)
}

for i := range yinzhengjie{ //只遍歷key
fmt.Println(i)
}
}

 

#以上代碼執行結果如下：
map[3:d 4:e 5:f 6:g 7:h 0:a 1:b 2:c]
key= 6 value= g
key= 7 value= h
key= 0 value= a
key= 1 value= b
key= 2 value= c
key= 3 value= d
key= 4 value= e
key= 5 value= f
3
4
5
6
7
0
1
2

 5.原地修改字典的Value

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

type Student struct {
ID int
NAME string
}

func main() {
dict := make(map[int]*Student)
dict[1] = &Student{
ID:100,
NAME:"yinzhengjie",
}

dict[2] = &Student{
ID:200,
NAME:"尹正傑",
}

fmt.Println(dict[1])
s := dict[1]
s.ID = 100000 //原地修改字典的value.
fmt.Println(dict)
fmt.Println(dict[1])
}

 

#以上代碼執行結果如下：
&{100 yinzhengjie}
map[1:0xc042044400 2:0xc042044420]
&{100000 yinzhengjie}

 

三.map的常用技巧

1.判斷map鍵值是否存在

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
yinzhengjie := make(map[int]string)
letter := []string{"a","b","c","d","e","f","g","h"}
for k,v := range letter{
yinzhengjie[k] = v
}
fmt.Printf("字典中的值為：【%v】\n",yinzhengjie) //注意，字典是無序的喲！
if v, ok := yinzhengjie[1]; ok {
fmt.Println("存在key=",v)
}else {
fmt.Println("沒有找到key=",v)
}

v ,ok := yinzhengjie[1]
if ok {
fmt.Println("再一次確認，已經存在key=",v)
}else {
fmt.Println("再一次確認，沒有找到key=",v)
}
}

 

#以上代碼執行結果如下：
字典中的值為：【map[3:d 4:e 5:f 6:g 7:h 0:a 1:b 2:c]】
存在key= b
再一次確認，已經存在key= b

 

2.map的排序

　　我們都知道字典的默認都是無需的，但是我們可以借用標准庫的包來進行基於字母或數字的順序來排序，從而達到我們想要的結果，我們就以2016全球計算機語言排行前十的案例來展示吧：

 
            /*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ 
            package main 
            import (
 "fmt"
 "sort"
) 
            func main() {
 var ProgramingLanguage = map[string]int{
 "Java": 0,
 "C": 1,
 "C++": 2,
 "Python": 3,
 "C#": 4,
 "PHP": 5,
 "JavaScript": 6,
 "Visual Basic.NET": 7,
 "Perl": 8,
 "Assembly language": 9,
 "Ruby": 10,
 }
 var SortString []string
 for k := range ProgramingLanguage {
 SortString = append(SortString, k)
 }
 sort.Strings(SortString) //會根據字母的順序進行排序。
 for _, k := range SortString {
 fmt.Println("Key:", k, "Value:", ProgramingLanguage[k])
 }
} 
              
            #以上代碼執行結果如下：
Key: Assembly language Value: 9
Key: C Value: 1
Key: C# Value: 4
Key: C++ Value: 2
Key: Java Value: 0
Key: JavaScript Value: 6
Key: PHP Value: 5
Key: Perl Value: 8
Key: Python Value: 3
Key: Ruby Value: 10
Key: Visual Basic.NET Value: 7 
             
           

3.map的嵌套

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

type EmployeeInformation map[string]int

func main() {

StaffQuarters := make(map[string]EmployeeInformation)
EmployeeNumber := make(EmployeeInformation)
EmployeeNumber["yinzhengjie"] = 23
EmployeeNumber["bingan"] = 24

StaffQuarters["888"] = EmployeeNumber
StaffQuarters["999"] = EmployeeInformation{"fanbinxin": 25, "zhouzhiruo": 26,}
fmt.Println(StaffQuarters)
}

 

#以上代碼執行結果如下：
map[888:map[bingan:24 yinzhengjie:23] 999:map[fanbinxin:25 zhouzhiruo:26]]

 

4.map的嵌套用法展示

 

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
Province:=make(map[string]map[string][]string) //定義省的字典
City:=make(map[string][]string) //定義市區的字典
Scenery := make(map[string][]string) //定義景區的字典
Scenery["西安"] = []string{ "秦始皇兵馬俑","大雁塔","大唐芙蓉園","華清池","黃巢堡國家森林公園","西安碑林博物館","驪山國家森林公園","西安城牆","秦始皇陵","翠華山",}
Scenery["安康"] = []string{"中壩大峽谷","香溪洞","安康雙龍生態旅游度假區","瀛湖生態旅游景區","簡車灣休閑景區","南宮山","天書峽景區","漢江燕翔洞景區","飛渡峽-黃安壩景區","千層河",}
City["西安市區"]=[]string{"新城區","碑林區","蓮湖區","灞橋區","未央區","雁塔區","閻良區","臨潼區","長安區","高陵區","咸陽區"}
City["安康市區"]=[]string{"漢濱區","漢陰縣","石泉縣","寧陝縣","紫陽縣","嵐皋縣","平利縣","鎮平縣","旬陽縣","白河縣",}
Province["陝西"]=City
City["西安景區"] = Scenery["西安"]
City["安康景區"] = Scenery["安康"]
for k,v := range Province{
fmt.Println(k,v)
for x,y := range v{
fmt.Println(x,y)
}
}
}

 

#以上代碼執行結果如下：
陝西 map[安康市區:[漢濱區 漢陰縣 石泉縣 寧陝縣 紫陽縣 嵐皋縣 平利縣 鎮平縣 旬陽縣 白河縣] 西安景區:[秦始皇兵馬俑 大雁塔 大唐芙蓉園 華清池 黃巢堡國家森林公園 西安碑林博物館 驪山國家森林公園 西安城牆 秦始皇陵 翠華山] 安康景區:[中壩大峽谷 香溪洞 安康雙龍生態旅游度假區 瀛湖生態旅游景區 簡車灣休閑景區 南宮山 天書峽景區 漢江燕翔洞景區 飛渡峽-黃安壩景區 千層河] 西安市區:[新城區 碑林區 蓮湖區 灞橋區 未央區 雁塔區 閻良區 臨潼區 長安區 高陵區 咸陽區]]
西安景區 [秦始皇兵馬俑 大雁塔 大唐芙蓉園 華清池 黃巢堡國家森林公園 西安碑林博物館 驪山國家森林公園 西安城牆 秦始皇陵 翠華山]
安康景區 [中壩大峽谷 香溪洞 安康雙龍生態旅游度假區 瀛湖生態旅游景區 簡車灣休閑景區 南宮山 天書峽景區 漢江燕翔洞景區 飛渡峽-黃安壩景區 千層河]
西安市區 [新城區 碑林區 蓮湖區 灞橋區 未央區 雁塔區 閻良區 臨潼區 長安區 高陵區 咸陽區]
安康市區 [漢濱區 漢陰縣 石泉縣 寧陝縣 紫陽縣 嵐皋縣 平利縣 鎮平縣 旬陽縣 白河縣]

 

四.map的進階知識

1.map的挖坑

　　Captial["北京"]["大興區"]會發現這個值已經沒有了，取而代之的是Captial["北京"]["密雲縣"]這是因為 Area 和 County 都是 map[string]int 類型的數據，Golang 直接把 ["大興區"] 里的數據從 Area 替換成了 County，而不會遞歸地添加 map 中缺失的數據。

 
             
            /*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ 
            package main 
            import "fmt" 
            func main() {
 Captial := make(map[string]map[string]int)
 Area := make(map[string]int)
 Area["大興區"] = 100
 Captial["北京"] = Area
 County := make(map[string]int)
 County["密雲縣"] = 200
 fmt.Println(Captial["北京"]["大興區"]) //目前是可以訪問到“Captial["北京"]["大興區"]”的值的
 Captial["北京"] = County
 fmt.Println(Captial["北京"]["大興區"]) //但是你執行了上一行的代碼，你會發現你訪問不到它的值100啦，但是你卻發現可以訪問下面一行代碼的值。
 fmt.Println(Captial["北京"]["密雲縣"])
} 
              
            
#以上代碼執行結果如下：
100
0
200 
           

2.map的填坑

　　你自己想到上面的解決方法了沒？其實很簡單，我們只要做一個條件判斷即可，代碼如下：

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
Captial := make(map[string]map[string]int)
Area := make(map[string]int)
Area["大興區"] = 100
Captial["北京"] = Area

if _, ok := Captial["北京"]; ok {
Captial["北京"]["密雲縣"] = 200 //判斷，如果存在Captial["北京"]這個key就只做字典的追加操作。
}else {
County := make(map[string]int)
Captial["北京"] = County
County["密雲縣"] = 200 //如果不存在就
}
fmt.Println(Captial["北京"]["大興區"]) //可以訪問到“Captial["北京"]["大興區"]”的值100啦。
fmt.Println(Captial["北京"]["密雲縣"])
}

 

#以上代碼執行結果如下：
100
200

 

3.定義一個集合的思想

　　了解過Python的童鞋，可能聽說過集合，但是我要告訴你一個好消息和一個壞消息，你想先聽哪一個？壞消息就是Golang沒有集合這個概念；好消息是我們可以用Golang的make函數來實現集合的思想，下面跟我一起看個例子吧！

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import "fmt"

func main() {
set := make(map[string]bool) //定義一個map
set["yinzhengjie"] = true //給已經存在的變量定義為真
if set["yinzhengjie"] {
fmt.Printf("已經存在明為yinzhengjie的key,其值為【%v】\n",set["yinzhengjie"])

} else {
fmt.Println("該變量不存在！")
}

if set["yzj"] { //判斷是否 存在變量
fmt.Println("已經存在該變量")

} else {
fmt.Printf("不存在名為“yzj”的key,其值為【%v】\n",set["yzj"])

}
fmt.Println(set) //我們來一起查看一下這個網站吧。
}

 

#以上代碼執行結果如下：
已經存在該變量key,其值為【true】
不存在名為“yzj”的key,其值為【false】
map[yinzhengjie:true]

 

4.map的尋址

 　　golang中的map並沒有保證它們的value值的地址是不可變的，因為value值的地址很有可能被重新分配。在golang中，一個容量不斷增長的map可能會導致原來map中的一些元素發生rehashing，使得他們被重新分配到新的storage location上，這樣可能會導致原先得到的address變得不可用。就是所謂的map member 的 not addresable。

　　換句話說，在golang設計的時候，map中的value值應該是地址不可達的，就是說直接取map中的元素的地址會報錯.一個修改的辦法就是把value值設置成為指針的形式，這樣就相當於添加了一個額外的記錄（entry），即使真正需要的那個值的位置發生了變化，也可以重定向(redirection)過去。

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
"fmt"
)

type NameType struct { //定義一個結構體，類似Python語言中定義一個類的概念。
Blog string
}

func main() {
BlogAddress := make(map[string]*NameType)
BlogAddress["yinzhengjie"] = &NameType{} //這里賦值的是指針。
BlogAddress["yinzhengjie"].Blog = "http://www.cnblogs.com/yinzhengjie"
fmt.Println(BlogAddress)
}

 

#以上代碼執行結果如下：
map[yinzhengjie:0xc042008230]

 

5.擴展小知識：make和new的區別

 　　make 只能為 slice、map或 channel 類型分配內存並初始化，同時返回一個有初始值的 slice、map 或 channel 類型引用，不是指針。內建函數 new 用來分配內存，它的第一個參數是一個類型，不是一個值，它的返回值是一個指向新分配類型零值的指針。