【go语言学习】映射map

Go语言中的map(映射、字典)是一种内置的数据结构，它是一个无序的key-value对的集合。
Go语言中的map是引用类型，必须初始化才能使用。

一、map的定义和初始化

go语言中map声明的语法：

var m = map[keyType]valueType
其中：keyType-键key的类型
           valueType-值value的类型

package main

import "fmt"

func main() {
	var m map[int]string
	fmt.Println(m)
	fmt.Println(m == nil)
	m[1] = "tom"
	fmt.Println(m)
}

运行结果

map[]
true
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
        E:/golang/go_project/main.go:9 +0x107
exit status 2

但这样声明的map的初始值为nil，是不能存放键值对，需要使用make()函数类分配内存。

m = make(map[keyType]valueType, [cap])
其中：cap-表示map的容量，非必须，但建议初始化时指定一个合适的容量。

package main

import "fmt"

func main() {
	var m map[int]string
	m = make(map[int]string, 10)
	fmt.Println(m)
	fmt.Println(m == nil)
	m[1] = "tom"
	fmt.Println(m)
}

运行结果

map[]
false
map[1:tom]

也可以直接声明和赋值

var m = map[keyType]valueType {
           key: value,
           key: value,
           }

package main

import "fmt"

func main() {
	m := map[int]string{
		1: "tom",
		2: "jack",
	}
	fmt.Println(m)
}

运行结果

map[1:tom 2:jack]

二、map的操作

1、添加

map[key] = value

注意：

• map里所有key的数据类型必须是相同的，value的数据类型也必须相同，但key和value的数据类型可以不相同
• map里key可以是所有可比较的类型，如布尔型、整数型、浮点型、复杂型、字符串型等
• map里key是唯一的，后添加的key-value，会覆盖前面的key-value

package main

import "fmt"

func main() {
	m := make(map[int]string, 10)
	m[1] = "tom"
	m[2] = "jack"
	fmt.Println(m)
	m[1] = "lili"
	fmt.Println(m)
}

运行结果

map[1:tom 2:jack]
map[1:lili 2:jack]

2、取值

map[key] 可以获得key对应的value值

但是当key如果不存在的时候，我们会得到该value值类型的默认值，比如string类型得到空字符串，int类型得到0。但是程序不会报错。

所以我们可以使用ok-idiom获取值，可知道key/value是否存在

value, ok := map[key]

package main

import "fmt"

func main() {
	m := make(map[int]string, 10)
	m = map[int]string{
		1: "tom",
		2: "jack",
	}
	fmt.Println(m[3]) // 返回string的默认值""
	v, ok := m[3]
	if ok {
		fmt.Println("3-", v)
	} else {
		fmt.Println("查无此人！")
	}
}

运行结果

查无此人！

3、删除

使用delete()内建函数从map中删除一组键值对，如果key存在则删除，如果key不存在则不做任何操作也不报错

delete(map, key)
其中：map-表示要删除键值对的map
           key-表示要删除的键值对的键

package main

import "fmt"

func main() {
	m := make(map[int]string, 10)
	m = map[int]string{
		1: "tom",
		2: "jack",
	}
	delete(m, 2)
	delete(m, 3)
	fmt.Println(m)
}

运行结果

map[1:tom]

4、遍历

go语言中使用for range遍历map，遍历的结果是无序的。

package main

import "fmt"

func main() {
	m := make(map[int]string, 10)
	m = map[int]string{
		1: "tom",
		2: "jack",
		3: "lili",
		4: "marry",
	}
	for k, v := range m {
		fmt.Printf("%v-%v	", k, v)
	}
}

运行结果

3-lili  4-marry 1-tom   2-jack

5、map的长度

len(map)可以获取map的长度

两个map也是不能进行比较的，map唯一可以合法比较的对象是nil map can only be compared to nil， 应该用len(map) == 0来判断map是否为空

三、map的注意事项

1、map是引用类型

go语言中和切片一样，map也是引用数据类型，赋值和传参都是浅拷贝，传递的是map的地址。它们都指向相同的内部数据结构，因此，一个的变化会反映到另一个。

package main

import "fmt"

func main() {
	m := make(map[int]string, 10)
	m = map[int]string{
		1: "tom",
		2: "jack",
		3: "lili",
		4: "marry",
	}
	m2 := m
	m2[2] = "小小强"
	fmt.Println(m)  //map[1:tom 2:小小强 3:lili 4:marry]
	fmt.Println(m2) //map[1:tom 2:小小强 3:lili 4:marry]
	test(m)
	fmt.Println(m) //map[1:小强 2:小小强 3:lili 4:marry]
}

func test(m map[int]string) {
	m[1] = "小强"
}

运行结果

map[1:tom 2:小小强 3:lili 4:marry]
map[1:tom 2:小小强 3:lili 4:marry]
map[1:小强 2:小小强 3:lili 4:marry]

2、map&slice

map和slice结合使用，可以是

• slice的元素为一个map类型

package main

import "fmt"

func main() {
	m1 := make(map[string]string, 2)
	m1 = map[string]string{
		"name":    "tom",
		"address": "上海市",
	}
	m2 := make(map[string]string, 4)
	m2 = map[string]string{
		"name":    "jack",
		"address": "北京市",
	}
	m3 := make(map[string]string, 6)
	m3 = map[string]string{
		"name":    "marry",
		"address": "苏州市",
	}
	s := make([]map[string]string, 3, 10)
	s = []map[string]string{m1, m2, m3}
	fmt.Println(s)
	for k1, v1 := range s {
		fmt.Printf("第%v个人信息：
", k1+1)
		for k2, v2 := range v1 {
			fmt.Printf("	%v:%v
", k2, v2)
		}
	}
}

运行结果

[map[address:上海市 name:tom] map[address:北京市 name:jack] map[address:苏州市 name:marry]]
第1个人信息：
        name:tom
        address:上海市
第2个人信息：
        name:jack
        address:北京市
第3个人信息：
        address:苏州市
        name:marry

• map的value为一个slice类型

package main

import "fmt"

func main() {
	m := make(map[string][]int, 2)
	m = map[string][]int{
		"tom":  []int{80, 98, 95},
		"jack": []int{94, 87, 91},
	}
	fmt.Println(m)
}

运行结果

map[jack:[94 87 91] tom:[80 98 95]]