-de8bd8f33c3e44a59907dafe1884f228.png)
Go 语言中提供的映射关系容器为 map，其内部使用散列表（hash）实现。
map 是一种无序的基于 key-value 的数据结构，Go 语言中的 map 是引用类型，必须初始化才能使用。
map 定义
Go 语言中 map 的定义语法如下：
map[KeyType]ValueType
其中：
KeyType：表示键的类型。ValueType：表示键对应的值的类型。
map 类型的变量默认初始值为 nil，需要使用 make() 函数来分配内存。语法为：
make(map[KeyType]ValueType, [cap])
其中 cap 表示 map 的容量，该参数虽然不是必须的，但是我们应该在初始化 map 的时候就为其指定一个合适的容量。
map 的基本使用
map 中的数据都是成对出现的，map 的基本使用示例代码如下：
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)
}
/*
map[小明:100 张三:90]
100
type of a:map[string]int
*/
map 也支持在声明的时候填充元素，例如：
func main() {
userInfo := map[string]string{
"username": "go",
"password": "123456",
}
fmt.Println(userInfo) //
}
判断某个键是否存在
Go 语言中有个判断 map 中键是否存在的特殊写法，格式如下：
value, ok := map[key]
举个例子：
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)
} else {
fmt.Println("查无此人")
}
}
map 的遍历
Go 语言中使用 for range 遍历 map。
func main() {
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["娜扎"] = 60
for k, v := range scoreMap {
fmt.Println(k, v)
}
}
但我们只想遍历 key 的时候，可以按下面的写法：
func main() {
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["娜扎"] = 60
for k := range scoreMap {
fmt.Println(k)
}
}
注意： 遍历 map 时的元素顺序与添加键值对的顺序无关。
删除键值对
使用 delete() 内建函数从 map 中删除一组键值对，delete() 函数的格式如下：
delete(map, key)
其中：
map：表示要删除键值对的map；key：表示要删除的键值对的键；
示例代码如下：
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)
}
}
按顺序遍历 map
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])
}
}
元素为 map 类型的切片
下面的代码演示了切片中的元素为 map 类型时的操作：
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)
}
}
/*
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[]
*/
值为切片类型的 map
下面的代码演示了 map 中值为切片类型的操作：
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)
}
/*
map[]
after init
map[中国:[北京 上海]]
*/
练习
1、写一个程序，统计一个字符串中每个单词出现的次数。比如："how do you do" 中 how=1 do=2 you=1。
package main
import (
"fmt"
"strings"
)
func main() {
str := "how do you do"
str_slice := strings.Split(str, " ")
word_map := make(map[string]int, len(str_slice))
for _, s := range str_slice {
word_map[s]++
}
result_slice := make([]string, 0, len(word_map))
for k, v := range word_map {
result_slice = append(result_slice, fmt.Sprintf("%s=%d", k, v))
}
fmt.Println(strings.Join(result_slice," "))
}
/*
how=1 do=2 you=1
*/
2、观察下面代码，写出最终的打印结果。
func main() {
type Map map[string][]int
m := make(Map)
s := []int{1, 2}
s = append(s, 3)
fmt.Printf("%+v\n", s)
m["q1mi"] = s
s = append(s[:1], s[2:]...)
fmt.Printf("%+v\n", s)
fmt.Printf("%+v\n", m["q1mi"])
}
输出结果：
[1 2 3]
[1 3]
[1 3 3]
谨记一点：对切片的修改实际上是对底层数组的修改，所以在 s = append(s[:1], s[2:]...) 时实际就修改了底层数组。
可以添加如下代码输出一些信息协助我们判断：
fmt.Printf("m[qemi]指针=%p, len(m[\"qemi\"])=%v, cap(m[\"qemi\"])=%v\n", m["q1mi"], len(m["q1mi"]), cap(m["q1mi"]))
fmt.Printf("s指针=%p, len(s)=%v, cap(s)=%v\n", s, len(s), cap(s))
/*
m[qemi]指针=0xc000018120, len(m["qemi"])=3, cap(m["qemi"])=4
s指针=0xc000018120, len(s)=2, cap(s)=4
*/
可以看到，最终 s 和 m["qemi"] 指针还是相同，因为它们依旧是指向同一个数组。
只是在 m["q1mi"]=s 的时候 s 的长度是 3，此时赋值给 m["q1mi"] 则就是让 m["q1mi"] 和 s 指向同一个底层数组，并且 m["q1mi"] 的长度也为 3。
之后 s 被修改为长度为 2 了，由于它们依旧指向同一个数组，所以此时的输出结果就取决于它们的长度了，由于 m["q1mi"] 的长度为 3，所以输出底层数组的 3 个元素，同理 s 输出底层数组的 2 个元素。
转自：
评论区