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

　　　　　　　　　　　　　　　　　　　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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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 用來分配內存，它的第一個參數是一個類型，不是一個值，它的返回值是一個指向新分配類型零值的指針。