Go语言中的map

发表于 更新于 分类于 ，

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
27
28
29
30
31
32
func test1() {
	fmt.Printf("map的声明与初始化\n")
	// map key-value的数据结构 又叫字典
	// 1.声明
	var m map[string]string
	var m1 map[string]int
	var m2 map[string]map[string]string
	// 声明是不会分配内存的,初始化需要使用make
	m = make(map[string]string, 5)
	m["s1"] = "1"

	m1 = make(map[string]int, 5)
	m1["s1"] = 1

	// 注意 这里m2只初始化了key value同样需要初始化 否则会panic
	m2 = make(map[string]map[string]string, 5)
	m2["s1"] = make(map[string]string, 5)
	m2["s1"]["y1"] = "s1-y1-1"
	fmt.Printf("m:%v\n", m)
	fmt.Printf("m1:%v\n", m1)
	fmt.Printf("m2:%v\n", m2)

}

func main() {
	test1()
}

--------map的声明与初始化--------
m:map[s1:1]
m1:map[s1:1]
m2:map[s1:map[y1:s1-y1-1]]

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
27
28
29
func test2() {
	fmt.Printf("-------map的插入和更新-------\n")
	var m map[string]string = map[string]string{"s1": "hello world"}
	fmt.Printf("m:%v\n", m)
	m["s1"] = "hi"
	fmt.Printf("update m:%v\n", m)
	// 查找
	if _, ok := m["s1"]; ok {
		fmt.Printf("m[s1]:%v\n", m["s1"])
	}
	// 遍历map
	for k, v := range m {
		fmt.Printf("%s:%s\n", k, v)
	}
	// 删除map内的元素
	delete(m, "s1")
	fmt.Printf("len:%d\n", len(m))
}

func main() {
	test2()
}

-------map的插入和更新-------
m:map[s1:hello world]
update m:map[s1:hi]
m[s1]:hi
s1:hi
len:0

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
func modify(m map[string]map[string]string) {
	fmt.Printf("%p\n", m)
	// 判断m的key对应的map是否初始化
	if _, ok := m["s1"]; !ok {
		fmt.Println(ok)
		m["s1"] = make(map[string]string, 5)
	}
	m["s1"]["y1"] = "s1-y1-1"
	fmt.Printf("modify:m[s1][y1]:%v\n", m["s1"]["y1"])
}

func trans(m map[string]map[string]string) {
	// 遍历map嵌套
	for k, v := range m {
		fmt.Printf("k:%s\n", k)
		for k1, v1 := range v {
			fmt.Printf("%s:[%s:%v]\n", k, k1, v1)
		}
	}
}

func test3() {
	fmt.Printf("-------map嵌套的初始化-------\n")
	// map是引用类型 在传递时传递的时地址的副本
	m := make(map[string]map[string]string, 5)
	fmt.Printf("%p\n", m)
	modify(m)
	// 这里也能读取到modify对m的初始化和赋值
	fmt.Printf("test3:m[s1][y1]:%v\n", m["s1"]["y1"])

	m["s1"]["y2"] = "s1-y2-2"
	m["s1"]["y3"] = "s1-y3-3"
	m["s2"] = make(map[string]string, 5)
	m["s2"]["y1"] = "s2-y1-1"
	m["s2"]["y2"] = "s2-y2-2"
	m["s2"]["y3"] = "s2-y3-3"

	trans(m)
}

func main() {
	test3()
}

-------map嵌套的初始化-------
0xc00006a510
0xc00006a510
false
modify:m[s1][y1]:s1-y1-1
test3:m[s1][y1]:s1-y1-1
k:s1
s1:[y1:s1-y1-1]
s1:[y2:s1-y2-2]
s1:[y3:s1-y3-3]
k:s2
s2:[y1:s2-y1-1]
s2:[y2:s2-y2-2]
s2:[y3:s2-y3-3]

slice与map嵌套的初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func test4() {
	fmt.Printf("-------slice与map嵌套的初始化-------\n")
	a := make([]map[string]int, 5)
	if a[0] == nil {
		a[0] = make(map[string]int, 5)
	}
	a[0]["s1"] = 1
	a[0]["s2"] = 2
	a[0]["s3"] = 3
	fmt.Printf("%v\n", a)
}

func main() {
	test3()
}

-------slice与map嵌套的初始化-------
[map[s1:1 s2:2 s3:3] map[] map[] map[] map[]]

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
func test5() {
	fmt.Printf("---------------map排序-----------------\n")
	// Go的map是无序的 只在fmt.print打印时候有序
	a := make(map[string]string, 5)

	a["3"] = "hij"
	a["1"] = "abc"
	a["2"] = "def"
	a["4"] = "opq"

	for k, v := range a {
		fmt.Printf("%s,%s\n", k, v)
	}

	// 把map的key取出来放入slice进行排序
	slices := make([]string, 0, 5)
	for k, _ := range a {
		slices = append(slices, k)
	}
	fmt.Printf("排序前，key:%v\n", slices)
	sort.Strings(slices)
	fmt.Printf("排序后，key:%v\n", slices)

	for _, v := range slices {
		fmt.Printf("map[%s]:%s\n", v, a[v])
	}
}

func main() {
	test5()
}

---------------map排序-----------------
3,hij
1,abc
2,def
4,opq
排序前，key:[3 1 2 4]
排序后，key:[1 2 3 4]
map[1]:abc
map[2]:def
map[3]:hij
map[4]:opq

map反转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func test6() {
	fmt.Printf("---------------map反转-----------------\n")
	a := make(map[int]string, 5)
	b := make(map[string]int, 5)

	a[1] = "a"
	a[2] = "b"
	a[3] = "c"
	a[4] = "d"
	a[5] = "e"

	for k, v := range a {
		b[v] = k
	}
	fmt.Printf("反转后:%v\n", b)
}

func main() {
	test6()
}

---------------map反转-----------------
反转后:map[a:1 b:2 c:3 d:4 e:5]