Golang 【basic_leaming】map 详解

妖狐艹你老母 2023-10-07 22:17 9阅读 0赞

#### 阅读目录 ####

*  map 的介绍
 *   *  map 基本使用
     *  判断某个键是否存在
     *  map 的遍历
     *  使用 delete() 函数删除键值对
     *  【案例 1】按照指定顺序遍历 map
     *  元素为 map 类型的切片
     *  值为切片类型的 map
     *  练习题

## map 的介绍 ##

map 是一种无序的基于 `key-value` 的数据结构，Go 语言中的 map 是引用类型，必须初始化才能使用。

Go 语言中 map 的定义语法如下：

map[KeyType]ValueType

其中：

KeyType：表示键的类型。  
ValueType：表示键对应的值的类型。

map 类型的变量默认初始值为 nil，需要使用 make() 函数来分配内存。

语法为：make: 用于 slice，map，和 channel 的初始化。

make(map[KeyType]ValueType, [cap])

其中 cap 表示 map 的容量，该参数不是必须的。

> 注意：获取 map 的容量不能使用 cap, cap 返回的是数组切片分配的空间大小, 根本不能用于 map。要获取 map 的容量，可以用len 函数。

### map 基本使用 ###

map 中的数据都是成对出现的，map 的基本使用示例代码如下：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	scoreMap := make(map[string]int, 8)
    	scoreMap["张三"] = 90
    	scoreMap["小明"] = 100
    	fmt.Println(scoreMap)
    	fmt.Println(scoreMap["小明"])
    	fmt.Printf("type of a:%T\n", scoreMap)
    }

PS E:\golang\src> go run .\main.go
    map[小明:100 张三:90]
    100
    type of a:map[string]int
    PS E:\golang\src>

map 也支持在声明的时候填充元素，例如：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	userInfo := map[string]string{
        
    		"username": "IT 小王子",
    		"password": "123456",
    	}
    	fmt.Println(userInfo)
    }

PS E:\golang\src> go run .\main.go
    map[password:123456 username:IT 小王子]
    PS E:\golang\src>

### 判断某个键是否存在 ###

Go 语言中有个判断 map 中键是否存在的特殊写法，格式如下:

value, ok := map 对象[key]

举个例子：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	scoreMap := make(map[string]int)
    	scoreMap["张三"] = 90
    	scoreMap["小明"] = 100
    
    	// 如果key 存在ok 为true,v 为对应的值；不存在ok 为false,v 为值类型的零值
    	v, ok := scoreMap["张三"]
    	if ok {
        
    		fmt.Println(v) // 90
    	} else {
        
    		fmt.Println("查无此人")
    	}
    }

### map 的遍历 ###

Go 语言中使用 for range 遍历 map。

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	scoreMap := make(map[string]int)
    	scoreMap["张三"] = 90
    	scoreMap["小明"] = 100
    	scoreMap["娜扎"] = 60
    	for k, v := range scoreMap {
        
    		fmt.Println(k, v)
    	}
    }

PS E:\golang\src> go run .\main.go
    张三 90
    小明 100
    娜扎 60
    PS E:\golang\src>

但我们只想遍历 key 的时候，可以按下面的写法：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	scoreMap := make(map[string]int)
    	scoreMap["张三"] = 90
    	scoreMap["小明"] = 100
    	scoreMap["娜扎"] = 60
    	for k := range scoreMap {
        
    		fmt.Println(k)
    	}
    }

PS E:\golang\src> go run .\main.go
    小明
    娜扎
    张三
    PS E:\golang\src>

注意： 遍历 map 时的元素顺序与添加键值对的顺序无关。

### 使用 delete() 函数删除键值对 ###

使用 delete() 内建函数从 map 中删除一组键值对，delete() 函数的格式如下：

delete(map 对象, key)

*  map 对象：表示要删除键值对的 map 对象。
 *  key:表示要删除的键值对的键。

示例代码如下：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	scoreMap := make(map[string]int)
    	scoreMap["张三"] = 90
    	scoreMap["小明"] = 100
    	scoreMap["娜扎"] = 60
    	delete(scoreMap, "小明") // 将小明:100 从map 中删除
    	for k, v := range scoreMap {
        
    		fmt.Println(k, v)
    	}
    }

PS E:\golang\src> go run .\main.go
    张三 90
    娜扎 60
    PS E:\golang\src>

### 【案例 1】按照指定顺序遍历 map ###

package main
    
    import (
    	"fmt"
    	"math/rand"
    	"sort"
    	"time"
    )
    
    func main() {
        
    	rand.Seed(time.Now().UnixNano()) //初始化随机数种子
    	var scoreMap = make(map[string]int, 200)
    	for i := 0; i < 100; i++ {
        
    		key := fmt.Sprintf("stu%02d", i) //生成stu 开头的字符串
    		value := rand.Intn(100)          //生成0~99 的随机整数
    		scoreMap[key] = value
    	}
    	//取出map 中的所有key 存入切片keys
    	var keys = make([]string, 0, 200)
    	for key := range scoreMap {
        
    		keys = append(keys, key)
    	}
    	//对切片进行排序
    	sort.Strings(keys)
    	//按照排序后的key 遍历map
    	for _, key := range keys {
        
    		fmt.Println(key, scoreMap[key])
    	}
    }

PS E:\golang\src> go run .\main.go
    stu00 2
    stu01 83
    stu02 27
    stu03 19
    stu04 87
    stu05 22
    stu06 64
    stu07 94
    stu08 14
    stu09 3
    stu10 13
    stu11 75
    stu12 64
    stu13 81
    stu14 60
    stu15 57
    stu16 29
    stu17 80
    stu18 97
    stu19 43
    stu20 54
    stu21 21
    stu22 36
    stu23 73
    stu24 92
    stu25 9
    stu26 97
    stu27 30
    stu28 36
    stu29 38
    stu30 71
    stu31 50
    stu32 50
    stu33 45
    stu34 39
    stu35 26
    stu36 4
    stu37 89
    stu38 91
    stu39 59
    stu40 7
    stu41 68
    stu42 11
    stu43 13
    stu44 29
    stu45 63
    stu46 80
    stu47 2
    stu48 59
    stu49 66
    stu50 68
    stu51 91
    stu52 39
    stu53 84
    stu54 55
    stu55 11
    stu56 95
    stu57 48
    stu58 70
    stu59 66
    stu60 95
    stu61 34
    stu62 26
    stu63 51
    stu64 89
    stu65 89
    stu66 24
    stu67 63
    stu68 46
    stu69 82
    stu70 67
    stu71 86
    stu72 71
    stu73 80
    stu74 55
    stu75 4
    stu76 48
    stu77 73
    stu78 21
    stu79 65
    stu80 69
    stu81 85
    stu82 90
    stu83 8
    stu84 41
    stu85 70
    stu86 49
    stu87 97
    stu88 72
    stu89 55
    stu90 95
    stu91 98
    stu92 66
    stu93 15
    stu94 88
    stu95 67
    stu96 73
    stu97 37
    stu98 33
    stu99 79
    PS E:\golang\src>

### 元素为 map 类型的切片 ###

下面的代码演示了切片中的元素为 map 类型时的操作：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	var mapSlice = make([]map[string]string, 3)
    	for index, value := range mapSlice {
        
    		fmt.Printf("index:%d value:%v\n", index, value)
    	}
    	fmt.Println("after init")
    	// 对切片中的map 元素进行初始化
    	mapSlice[0] = make(map[string]string, 10)
    	mapSlice[0]["name"] = "小王子"
    	mapSlice[0]["password"] = "123456"
    	mapSlice[0]["address"] = "海淀区"
    	for index, value := range mapSlice {
        
    		fmt.Printf("index:%d value:%v\n", index, value)
    	}
    }

PS E:\golang\src> go run .\main.go
    index:0 value:map[]
    index:1 value:map[]
    index:2 value:map[]
    after init
    index:0 value:map[address:海淀区 name:小王子 password:123456]
    index:1 value:map[]
    index:2 value:map[]
    PS E:\golang\src>

### 值为切片类型的 map ###

下面的代码演示了 map 中值为切片类型的操作：

package main
    
    import (
    	"fmt"
    )
    
    func main() {
        
    	var sliceMap = make(map[string][]string, 3)
    	fmt.Println(sliceMap)
    	fmt.Println("after init")
    	key := "中国"
    	value, ok := sliceMap[key]
    	if !ok {
        
    		value = make([]string, 0, 2)
    	}
    
    	value = append(value, "北京", "上海")
    	sliceMap[key] = value
    	fmt.Println(sliceMap)
    }

PS E:\golang\src> go run .\main.go
    map[]
    after init
    map[中国:[北京 上海]]
    PS E:\golang\src>

### 练习题 ###

写一个程序，统计一个字符串中每个单词出现的次数。  
比如：`”how do you do” 中 how=1 do=2 you=1`。

package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
        
    	var wordMap = make(map[string]int)
    	var str = "how do you do"
    	var arrSlice = strings.Split(str, " ")
    	for _, word := range arrSlice {
        
    		wordMap[word]++
    	}
    	fmt.Println(wordMap)
    }

PS E:\golang\src> go run .\main.go
    map[do:2 how:1 you:1]
    PS E:\golang\src>