09.map

# 01.map介绍

# 1.1 map说明

map 是一种无序的基于 key-value 的数据结构，Go 语言中的 map 是引用类型，必须初始化才能使用。
Go 语言中 map 的定义语法如下：map[KeyType]ValueType
其中:
- KeyType:表示键的类型。
- ValueType:表示键对应的值的类型。
- map 类型的变量默认初始值为 nil，需要使用 make()函数来分配内存。
其中 cap 表示 map 的容量，该参数虽然不是必须的。
注意：获取 map 的容量不能使用 cap, cap 返回的是数组切片分配的空间大小, 根本不能用于map。
要获取 map 的容量，可以用 len 函数。

# 02.定义map

# 2.1 map定义：法1

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

1
2
3
4
5
6
7
8
9
10
11
12

# 2.2 map定义：法2

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

1
2
3
4
5
6
7
8
9
10
11

# 2.3 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)
	}
}
/*
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[]
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 03.map基本使用

# 3.1 判断某个键是否存在

package main
import (
	"fmt"
)
func main() {
	userInfo := map[string]string{
		"username": "zhangsan",
		"password": "123456",
	}
	v, ok := userInfo["username"]
	if ok {
		fmt.Println(v)    // zhangsan
	}else {
		fmt.Println("map中没有此元素")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 3.2 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)
	}
}
/*
娜扎 60
张三 90
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

111111111111

# 04.map遍历

# 4.1 遍历key和value

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)
	}
}
/*
张三 90
小明 100
娜扎 60
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 4.2 只遍历Key

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 4.3 顺序遍历map

package main
import (
	"fmt"
	"sort"
)
func main() {
	// 第一：生成字典，scoreMap
	var scoreMap = make(map[string]int, 200)
	for i := 0; i < 10; i++ {
		key := fmt.Sprintf("stu%02d", i) //生成 stu 开头的字符串
		scoreMap[key] = i
	}
	
	// 第二：取出 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])
	}
}
/*
stu00 0
stu01 1
stu02 2
stu03 3
stu04 4
stu05 5
stu06 6
stu07 7
stu08 8
stu09 9
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

上次更新: 2024/3/13 15:35:10

← 08.切片 10.指针→