Go map

发表于
字数统计: 801 | 阅读时长 ≈ 4

map

类似其他语言中的哈希表或者字典，以key-value形式存储数据，key必须是支持==或者!-比较运算的类型，不可以是函数，map或者slice。

Map 查找比线性搜索快很多，但比使用索引访问数据的类型慢100倍。

Map使用make()创建，支持:=简写方式

make([keyType]valueType, cap)，其中cap表示容量，可省略

超出容量时会自动扩容，但尽量提供一个合理的初始值

键值对不存在时会自动添加，使用delete()删除某键值对

使用for range对map和slice进行迭代操作

初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func mapF1() {
	var m1 map[int]string
	m1 = map[int]string{}
	fmt.Println(m1)

	var m2 map[int]string
	m2 = make(map[int]string)
	// var m2 map[int]string = make(map[int]string)
	fmt.Println(m2)

	m3 := map[int]string{}
	fmt.Println(m3)

	m4 := make(map[int]string)
	fmt.Println(m4)
}

输出

1
2
3
4
map[]
map[]
map[]
map[]

元素操作

添加

1
2
3
4
5
6
7
8
9
func mapF2(){
	m := map[string]string{}
	m["name"] = "Bob"
	m["age"] = "18"
	fmt.Println(m)

	a := m["name"]
	fmt.Println(a)
}

输出

1
2
map[age:18 name:Bob]
Bob

删除

1
2
+ delete(m,"name")
+ fmt.Println(m)

输出

1
map[age:18]

复杂一点的map

1
2
3
4
5
6
7
8
9
10
11
func mapF3() {
	// 1 : {1:"123"}
	m := make(map[int]map[int]string)
	m2 := make(map[int]string)
	m2[0] = "Bob"

	m[0] = m2

	fmt.Println(m2)
	fmt.Println(m)
}

输出

1
2
map[0:Bob]
map[0:map[0:Bob]]

单独初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func mapF3() {
	// 1 : {1:"123"}
	m := make(map[int]map[int]string)

	a, ok := m[0][0]
	fmt.Println(a, ok)

	if !ok {
		m[0] = make(map[int]string)
	}
	m[0][0] = "OK"

	fmt.Println(m)
}

输出

1
2
 false
map[0:map[0:OK]]

循环迭代

slice

1
2
3
4
5
6
func sliceDemo() {
	a := []int{1, 2, 3, 4, 5, 6}
	for i, v := range a {
		fmt.Println(i, v)
	}
}

输出

1
2
3
4
5
6
0 1
1 2
2 3
3 4
4 5
5 6

i是索引，v是具体的属性值，v是个拷贝，对其操作不会影响原来的map

1
2
3
4
5
6
7
m := make([]map[int]string, 5)
for _, v := range m {
	v = make(map[int]string, 1)
	v[1] = "OK"
	fmt.Println(v)
}
fmt.Println(m)

输出

1
2
3
4
5
6
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
[map[] map[] map[] map[] map[]]

m中并没有"OK"。所以为了影响map中，需要使用到索引，即第一个参数

1
2
3
4
5
6
7
8
9
func mapF6() {
	m := make([]map[int]string, 5)
	for i := range m {
		m[i] = make(map[int]string, 1)
		m[i][1] = "OK"
		fmt.Println(m[i])
	}
	fmt.Println(m)
}

_为省略

输出

1
2
3
4
5
6
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
[map[1:OK] map[1:OK] map[1:OK] map[1:OK] map[1:OK]]

map

1
2
3
4
5
6
7
m := make(map[int]string)
m[0] = "Hello"
m[1] = "Jmy"
m[2] = "Nice to meet you"
for i, v := range m {
   fmt.Println(i, v)
}

输出

1
2
3
0 Hello
1 Jmy
2 Nice to meet you

对map中元素进行操作

1
2
3
for i, v := range m {
+	m[i] = v + " 123"
}

输出

1
map[0:Hello 123 1:Jmy 123 2:Nice to meet you 123]

排序

无序性
1
2
3
4
5
6
7
8
9
10
func mapF7() {
   m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}
   s := make([]int,len(m))
   i := 0
   for key,_ := range m{
      s[i] = key
      i ++
   }
   fmt.Println(s)
}

输出

1
[5 1 2 3 4]
sort 包
1
2
3
4
5
6
7
8
9
10
import (
	"fmt"
+	"sort"
)


.... 省略

+ sort.Ints(s)
fmt.Println(s)

输出

1
[1 2 3 4 5]

练习

1
2
3
4
5
6
7
8
9
func mapF8() {
	m1 := map[int]string{1:  "a", 2: "b", 3: "c"}
	m2 := make(map[string]int,len(m1))
	for key,value := range m1{
		m2[value] = key
	}
	fmt.Println(m1)
	fmt.Println(m2)
}

输出

1
2
map[1:a 2:b 3:c]
map[a:1 b:2 c:3]
- the End -
0%