一、map的初始化

package main
import "fmt"
// map映射
func main()  {
    // 定義語法 map[KeyType][ValueType]
    // 只聲明了map類型 沒有初始化 a就是初始值nil
    var a map[string]int
    fmt.Println(a == nil)
    // map的初始化
    a = make(map[string]int, 2)
    fmt.Println(a == nil)
    // map中添加鍵值對
    a["jiayuan"] = 80
    a["jushi"] = 100
    a["xuye"] = 90
    fmt.Println(a)
    // 聲明map的同時完成初始化
    b := map[int]bool{
        1: true,
        2: false,
    }
    fmt.Println(b)
}

二、判斷某個鍵是否存在

package main
import "fmt"
// map映射
func main()  {
    // 判斷某個鍵存不存在
    var scoreMap = make(map[string]int, 8)
    scoreMap["jiayuan"] = 80
    scoreMap["jushi"] = 100
    value, ok := scoreMap["jiayuan"]
    if ok{
        fmt.Println("xuye在scoreMap中", value)
    }else{
        fmt.Println("查無此人")
    }
}

三、map的遍歷與刪除

package main
import "fmt"
// map映射
func main()  {
    // 遍歷map
    var scoreMap = make(map[string]int, 8)
    scoreMap["jiayuan"] = 80
    scoreMap["jushi"] = 100

    // for range
    // map是無序的 鍵值對合添加的順序無關
    for k, v := range scoreMap{
        fmt.Println(k, v)
    }
    // 只遍歷map中的key
    for k := range scoreMap{
        fmt.Println(k)
    }
    // 只遍歷map中的value
    for _, v := range scoreMap{
        fmt.Println(v)
    }

    // 刪除鍵值對
    delete(scoreMap, "jushi")
    fmt.Println(scoreMap)
}

四、map的有序遍歷

package main
import (
    "fmt"
    "math/rand"
    "sort"
)
// map映射
func main()  {
    // 按照某個固定順序遍歷map
    var scoreMap = make(map[string]int, 100)
    // 添加50個鍵值對
    for i:=0; i<50; i++{
        key := fmt.Sprintf("stu%02d", i) // 格式化輸出 兩位整數
        value := rand.Intn(100)
        scoreMap[key] = value
    }
    for k, v := range scoreMap{
        fmt.Println(k, v)
    }
    // 按照key從小到大的順序去遍歷scoreMap
    // 1. 先取出所有的key存放到切片中
    keys := make([]string, 0, 100)
    for k := range scoreMap{
        keys = append(keys, k)
    }
    // 2. 對key做排序
    sort.Strings(keys) // keys目前有序
    // 3. 按照排序后的key對scoreMap排序
    for _, key := range keys{
        fmt.Println(key, scoreMap[key])
    }
}

五、元素類型為map的切片

package main
import "fmt"
// map映射
func main()  {
    // 元素類型為map的切片
    var mapSlice = make([]map[string]int, 8, 8) // 只是完成了切片的初始化
    // [nil, nil, nil, nil, nil, nil, nil, nil]
    fmt.Println(mapSlice[0] == nil)
    // 還需要完成內部map元素的初始化
    fmt.Println(mapSlice[0])
    mapSlice[0] = make(map[string]int, 8) // 完成了map的初始化
    fmt.Println(mapSlice[0])
    mapSlice[0]["jiayuan"] = 80
    fmt.Println(mapSlice)
}

六、元素類型為map的切片

package main
import "fmt"
// map映射
func main() {
    // 值為切片的map
    var sliceMap = make(map[string][]int, 8) // 只完成了map的初始化
    v, ok := sliceMap["中國"]
    if ok {
        fmt.Println(v)
    } else {
        // sliceMap中沒有中國這個鍵
        sliceMap["中國"] = make([]int, 8) // 完成了對切片的初始化
        sliceMap["中國"][0] = 100
        sliceMap["中國"][1] = 200
        sliceMap["中國"][3] = 300
    }
    for k, v := range sliceMap{
        fmt.Println(k, v)
    }
}

作業(yè)

package main
import (
    "fmt"
    "strings"
)
// map 映射
func main(){
    // 統(tǒng)計一個字符串中每個單詞出現(xiàn)的次數
    // "how do you do"中每個單詞出現(xiàn)的次數
    // 0. 定義一個map[string]int
    var s = "how do you do"
    var wordCount = make(map[string]int, 10)
    // 1. 字符串中都有哪些單詞
    words := strings.Split(s, " ")
    // 2. 遍歷單詞做統(tǒng)計
    for _, word := range words{
        _, ok := wordCount[word]
        if ok {
            // map中有這個單詞的統(tǒng)計記錄
            wordCount[word] += 1
        }else{
            // map中沒有這個單詞的統(tǒng)計記錄
            wordCount[word] = 1
        }
    }
    fmt.Println(wordCount)
}