Go语言基础08——map

一、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)
    }
}

作业

package main
import (
    "fmt"
    "strings"
)
// map 映射
func main(){
    // 统计一个字符串中每个单词出现的次数
    // "how do you do"中每个单词出现的次数
    // 0. 定义一个map[string]int
    var s = "how do you do"
    var wordCount = make(map[string]int, 10)
    // 1. 字符串中都有哪些单词
    words := strings.Split(s, " ")
    // 2. 遍历单词做统计
    for _, word := range words{
        _, ok := wordCount[word]
        if ok {
            // map中有这个单词的统计记录
            wordCount[word] += 1
        }else{
            // map中没有这个单词的统计记录
            wordCount[word] = 1
        }
    }
    fmt.Println(wordCount)
}