map 是一种特殊的数据结构：一种元素对（pair）的无序集合，pair 的一个元素是key，对应的另一个元素是value，所以这个结构也称为关联数组或字典。
map的读取和设置也类似slice一样，通过key来操作，只是slice的index只能是int类型，而map多了很多类型，可以是int，可以是string及所有完全定义了==与!=操作的类型。
初始化
map 是引用类型，可以使用如下声明：
make(map[KeyType]ValueType, initialCapacity)
make(map[KeyType]ValueType)
map[KeyType]ValueType{}
map[KeyType]ValueType{key1 : value1, key2 : value2, ... , keyN : valueN}
//声明一个key是字符串，值为int的字典，这种方式的声明需要在使用之前使用make初始化
var numbers map[string]int
numbers = make(map[string]int)
numbers["one"] = 1
numbers["two"] = 2
numbers["three"] = 3
未初始化的 map 的值是 nil。
func test1() {
map1 := make(map[string]string, 5) // 指定初始容量
map2 := make(map[string]string)
map3 := map[string]string{}
map4 := map[string]string{"a": "1", "b": "2", "c": "3"}
fmt.Println(map1, map2, map3, map4) // map[] map[] map[] map[a:1 b:2 c:3]
}
以上示例代码用4种方式分别创建map，其中第一种和第二种的区别在于，有没有指定初始容量，不过使用的时候则无需在意这些，因为map的本质决定了，一旦容量不够，它会自动扩容。
注意：必须要先初始化才能给map赋值设置元素，不然会引起 panic: assign to entry in nil map。
func main(){
ages01 := map[string]int{
"alice":31,
"bob":13,
}
ages02 := make(map[string]int)
ages02["chris"] =20 // 通过==进行map赋值
ages02["paul"] = 30
//age01和age02两种初始化的方式等价
m1 := make(map[string]int)
m2 := map[string]int{}
//m1和m2创建方式等价，都是创建了一个空的的map，这个时候m1和m2没有任何元素
for name,age := range ages01{
fmt.Printf("%s\t%d\n",name,age) // bob 13, alice 31
}
for name,age := range ages02{
fmt.Printf("%s\t%d\n",name,age) // chris 20, paul 30
}
var null_map map[string]int //声明但未初始化map，此时是map的零值状态（只有一个nil元素）
empty_map := map[string]int{} //创建了初始化了一个空的的map，这个时候empty_map没有任何元素
fmt.Println(m1 != nil && m2 != nil) //true
fmt.Println(len(null_map)==0) // true
fmt.Println(null_map ==nil) //true,此时是map的零值状态(nil)
fmt.Println(len(empty_map)==0) // true
fmt.Println(empty_map ==nil) //false,空的的map不等价于nil(map的零值状态)
empty_map["test"] = 12 //执行正常，空的的map可以赋值设置元素
null_map["test"] = 12 //panic: assignment to entry in nil map，无法给未初始化的map赋值设置元素
}
需要注意的几点
1）map是无序的，每次打印出来的map都会不一样，它不能通过index获取，而必须通过key获取；
2）map的长度是不固定的，也就是和slice一样，也是一种引用类型；
3）内置的len函数同样适用于map，返回map拥有的key的数量；
4）map的值可以很方便的修改，通过numbers["one"]=11可以很容易的把key为one的字典值该为11；
5）map和其他基本类型不同，它不是thread-safe，在多个go-routine存取时，必须使用mutex lock机制；
map元素的同步更改
m := make(map[string]string)
m["hello"] = "Hello"
m1 := m
m1["hello"] = "World"
map是一种引用类型，如果两个map同时指向一个底层，那么一个改变，另一个也相应的改变。
map中元素是否存在
rating := map[string]float32 {"c":5, "Go":4.5, "Python":5.2, "PHP":2.4}
csharpRating, ok := rating["c#"]
if ok {
// 存在
} else {
// 不存在
}
if _, ok := map[key]; ok {
//如果存在则执行
}
map元素遍历
range for 可用于遍历map 中所有的元素，不过需要注意因为 map本身是无序的，因此对于程序的每次执行，不能保证使用 range for 遍历 map的顺序总是一致的。例如：
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"steve": 12000,
"jamie": 15000,
}
personSalary["mike"] = 9000
for key, value := range personSalary {
fmt.Printf("personSalary[%s] = %d\n", key, value)
}
}
获取map中所有的key
sizes := map[string]int{"XL": 20,"L": 10,"M": 5}
// Loop over map and append keys to empty slice.
keys := []string{}
for key, _ := range sizes {
keys = append(keys, key)
}
// This is a slice of the keys.
fmt.Println(keys)
map元素增删改查
首先这里map元素的增加和修改元素的语法一致，只需要map[K]=V即可。例如：
package main
import (
"fmt"
)
func main() {
personSalary := make(map[string]int)
personSalary["steve"] = 12000 //增加元素
personSalary["jamie"] = 15000 //增加元素
personSalary["mike"] = 9000 //增加元素
fmt.Println("map before change", personSalary)
personSalary["mike"] = 10000 //修改元素
fmt.Println("map after change", personSalary)
}
输出：
map before change map[steve:12000 jamie:15000 mike:9000]
map after change map[steve:12000 jamie:15000 mike:10000]
删除元素需要使用内置函数 delete，该函数根据键来删除一个元素。需要强调delete函数没有返回值，例如：
package main
import (
"fmt"
)
func main() {
personSalary := map[string]int{
"steve": 12000,
"jamie": 15000,
}
personSalary["mike"] = 9000
fmt.Println("map before deletion", personSalary)
delete(personSalary, "steve")
fmt.Println("map after deletion", personSalary)
}
输出：
map before deletion map[steve:12000 jamie:15000 mike:9000]
map after deletion map[mike:9000 jamie:15000]
map作为函数参数
func main() {
colors := map[string]int {
"blue": 10,
"green": 20,
}
PrintGreen(colors)
}
func PrintGreen(colors map[string]int) {
fmt.Println(colors["green"])
}
按key进行排序
import (
"fmt"
"sort"
)
func main() {
m := make(map[int]string)
m[1] = "b"
m[2] = "c"
m[0] = "a"
var keys []int
for k := range m {
keys = append(keys, k)
}
sort.Ints(keys) // 排序：升序
for _, k := range keys {
fmt.Println("Key:", k, "Value:", m[k])
}
}
map的比较
Go 语言中map和slice，func一样，不支持 == 操作符，就是不能直接比较。唯一合法的就是和nil作比较，判断该map是不是零值状态。
如果想自定义一个函数，来比较两个map是否相等，就可以遍历比较它们的键和值是否完全相等，代码如下：
func map_equal(x,y map[string]string) bool {
if len(x) != len(y) {
return false
}
for k,xv :=range x {
if yv,ok := y[k]; !ok || yv != xv {
return false
}
}
return true
}
