golang基础语法（六）Map
目录
一、什么是Map
二、创建Map
1、方式1
2、方式2
三、遍历map
四、删除
五、线程安全的map
六、nil
1、nil 标识符无法比较
2、nil 不是关键字或保留字
3、nil 没有默认类型
4、不同类型 nil 的指针是一样的
5、nil 是 map、slice、pointer、channel、func、interface 的零值
6、不同类型的 nil 值占用的内存大小可能是不一样的
七、new和make
一、什么是Map
map 是一种无序的键值对的集合。
map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过map是无序的，我们无法决定它的返回顺序，这是因为 map 是使用hash表来实现的。
二、创建Map
1、方式1
map 是引用类型，可以使用如下方式声明：
//[keytype] 和 valuetype 之间允许有空格。
var mapname map[keytype]valuetype其中：
- mapname 为 map 的变量名。
- keytype 为键类型。
- valuetype 是键对应的值类型。
在声明的时候不需要知道 map 的长度，因为 map 是可以动态增长的，未初始化的 map 的值是 nil，使用函数 len() 可以获取 map 中 键值对的数目。
package main
import "fmt"
func main() {var mapLit map[string]intvar mapAssigned map[string]intmapLit = map[string]int{"one": 1, "two": 2}mapAssigned = mapLit//mapAssigned 是 mapList 的引用，对 mapAssigned 的修改也会影响到 mapList 的值。mapAssigned["two"] = 3fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])fmt.Printf("Map assigned at \"two\" is: %d\n", mapLit["two"])fmt.Printf("Map literal at \"ten\" is: %d\n", mapLit["ten"])
}2、方式2
make(map[keytype]valuetype)不要使用new创建map，否则会得到一个空引用的指针
map 可以根据新增的 key-value 动态的伸缩，因此它不存在固定长度或者最大限制，但是也可以选择标明 map 的初始容量 capacity，格式如下：
make(map[keytype]valuetype, cap)例如：
map2 := make(map[string]int, 100)当 map 增长到容量上限的时候，如果再增加新的 key-value，map 的大小会自动加 1，所以出于性能的考虑，对于大的 map 或者会快速扩张的 map，即使只是大概知道容量，也最好先标明。
既然一个 key 只能对应一个 value，而 value 又是一个原始类型，那么如果一个 key 要对应多个值怎么办？答案是：使用切片
例如，当我们要处理 unix 机器上的所有进程，以父进程（pid 为整形）作为 key，所有的子进程（以所有子进程的 pid 组成的切片）作为 value。
通过将 value 定义为 []int 类型或者其他类型的切片，就可以优雅的解决这个问题，示例代码如下所示：
// mp1 示例mp1 := make(map[int][]int)mp1[1] = []int{1, 2, 3}//slice := mp1[1] // 获取的是切片的副本slice1 := make([]int, len(mp1[1])) // 创建一个完全独立的副本（深拷贝）//slice[0] = 98 // 修改副本slice1[0] = 98 // 修改副本fmt.Println(mp1[1]) // 输出 [1 2 3]（深拷贝原始切片未改变）// mp2 示例mp2 := make(map[int]*[]int)mp2[1] = &[]int{1, 2, 3}slicePtr := mp2[1] // 获取的是指向切片的指针(*slicePtr)[0] = 99 // 通过指针修改原始切片fmt.Println(*mp2[1]) // 输出 [99 2 3]（原始切片已改变）三、遍历map
map 的遍历过程使用 for range 循环完成，代码如下：
scene := make(map[string]int)
scene["cat"] = 66
scene["dog"] = 4
scene["pig"] = 960
for k, v := range scene {fmt.Println(k, v)
}注意：map是无序的，不要期望 map 在遍历时返回某种期望顺序的结果
四、删除
使用 delete() 内建函数从 map 中删除一组键值对，delete() 函数的格式如下：
delete(map, 键)map 为要删除的 map 实例，键为要删除的 map 中键值对的键。
scene := make(map[string]int)
// 准备map数据
scene["cat"] = 66
scene["dog"] = 4
scene["pig"] = 960
delete(scene, "dog")
for k, v := range scene {fmt.Println(k, v)
}Go语言中并没有为 map 提供任何清空所有元素的函数、方法，清空map的唯一办法就是重新 make一个新的map，不用担心垃圾回收的效率，Go语言中的并行垃圾回收效率比写一个清空函数要高效的多。注意map 在并发情况下，只读是线程安全的，同时读写是线程不安全的。
五、线程安全的map
并发情况下读写 map 时会出现问题，代码如下：
// 创建一个int到int的映射
m := make(map[int]int)// 开启一段并发代码
go func() {// 不停地对map进行写入for {m[1] = 1}
}()// 开启一段并发代码
go func() {// 不停地对map进行读取for {_ = m[1]}
}()// 无限循环, 让并发程序在后台执行
for {
}运行代码会报错，输出如下：
fatal error: concurrent map read and map write错误信息显示，并发的 map 读和 map 写，也就是说使用了两个并发函数不断地对 map 进行读和写而发生了竞态问题，map 内部会对这种并发操作进行检查并提前发现。
需要并发读写时，一般的做法是加锁，但这样性能并不高，Go语言在 1.9 版本中提供了一种效率较高的并发安全的 sync.Map，sync.Map 和 map 不同，不是以语言原生形态提供，而是在 sync 包下的特殊结构。
sync.Map 有以下特性：
- 无须初始化，直接声明即可。
- sync.Map 不能使用 map 的方式进行取值和设置等操作，而是使用 sync.Map 的方法进行调用，Store 表示存储，Load 表示获取，Delete 表示删除。
- 使用 Range 配合一个回调函数进行遍历操作，通过回调函数返回内部遍历出来的值，Range 参数中回调函数的返回值在需要继续迭代遍历时，返回 true，终止迭代遍历时，返回 false。
package main
import ("fmt""sync"
)
func main() {//sync.Map 不能使用 make 创建var scene sync.Map// 将键值对保存到sync.Map//sync.Map 将键和值以 interface{} 类型进行保存。scene.Store("greece", 97)scene.Store("london", 100)scene.Store("egypt", 200)// 从sync.Map中根据键取值fmt.Println(scene.Load("london"))// 根据键删除对应的键值对scene.Delete("london")// 遍历所有sync.Map中的键值对//遍历需要提供一个匿名函数，参数为 k、v，类型为 interface{}，每次 Range() 在遍历一个元素时，都会调用这个匿名函数把结果返回。scene.Range(func(k, v interface{}) bool {fmt.Println("iterate:", k, v)return true})
}解释一下：
|
| 遍历 |
|
| 对每个键值对执行的操作 |
|
| 继续遍历 |
|
| 停止遍历 |
interface{}类似object接受任何类型
sync.Map 为了保证并发安全有一些性能损失，因此在非并发情况下，使用 map 相比使用 sync.Map 会有更好的性能
六、nil
在Go语言中
- 布尔类型的零值（初始值）为 false
- 数值类型的零值为 0
- 字符串类型的零值为空字符串
"" - 而指针、切片、映射、通道、函数和接口的零值则是 nil
nil和其他语言的null是不同的
1、nil 标识符无法比较
package main
import ("fmt"
)
func main() {//invalid operation: nil == nil (operator == not defined on nil)fmt.Println(nil==nil)
}2、nil 不是关键字或保留字
nil 并不是Go语言的关键字或者保留字，也就是说我们可以定义一个名称为 nil 的变量，比如下面这样：
//但不提倡这样做
var nil = errors.New("my god")3、nil 没有默认类型
package main
import ("fmt"
)
func main() {//error :use of untyped nilfmt.Printf("%T", nil)print(nil)
}4、不同类型 nil 的指针是一样的
package mainimport ("fmt"
)func main() {var arr []intvar num *intfmt.Printf("%p\n", arr) //0x0fmt.Printf("%p", num) //0x0
}
5、nil 是 map、slice、pointer、channel、func、interface 的零值
映射、切片、指针、通道、函数和接口
package main
import ("fmt"
)
func main() {var m map[int]stringvar ptr *intvar c chan intvar sl []intvar f func()var i interface{}fmt.Printf("%#v\n", m)fmt.Printf("%#v\n", ptr)fmt.Printf("%#v\n", c)fmt.Printf("%#v\n", sl)fmt.Printf("%#v\n", f)fmt.Printf("%#v\n", i)
}%#v是 Go 语言中一个强大的格式化动词，能显示变量的 类型 + 值
零值是Go语言中变量在声明之后但是未初始化被赋予的该类型的一个默认值。
6、不同类型的 nil 值占用的内存大小可能是不一样的
package main
import ("fmt""unsafe"
)
func main() {var p *struct{}fmt.Println( unsafe.Sizeof( p ) ) // 8var s []intfmt.Println( unsafe.Sizeof( s ) ) // 24var m map[int]boolfmt.Println( unsafe.Sizeof( m ) ) // 8var c chan stringfmt.Println( unsafe.Sizeof( c ) ) // 8var f func()fmt.Println( unsafe.Sizeof( f ) ) // 8var i interface{}fmt.Println( unsafe.Sizeof( i ) ) // 16
}具体的大小取决于编译器和架构
七、new和make
make 关键字的主要作用是创建 slice、map 和 Channel 等内置的数据结构，而 new 的主要作用是为类型申请一片内存空间，并返回指向这片内存的指针。
-
make 分配空间后，会进行初始化，new分配的空间被清零
-
new 分配返回的是指针，即类型 *Type。make 返回引用，即 Type；
-
new 可以分配任意类型的数据；