三、集合(map)

Map的使用-Golang-100-Days/day08_Map%E7%9A%84%E4%BD%BF%E7%94%A8.md)

1.1 什么是Map

Map是Go中文内置类型，它将一个值与一个键关联起来。可以使用相应的键检索值。
Map是一种无需的键值对的集合。Map最重要的一点是通过key来快速检索数据，key类似于索引，指向数据的值Map是一种集合，所以可以像迭代数组和切片那样迭代它，
Map是无序的，我们无法决定它的返回顺序，这是因为Map是使用hash表来实现的，也是引用类型。
使用map过程中需要注意的几点：

1. map是无序的，每次打印出来的map都会不一样，它不能通过获取index获取，而必须通过key获取
2. map和slice一样，也是一种引用类型
3. 内置的len函数同样适用于map，返回map拥有的key的数量
4. map的key可以是所有可比较的类型，如布尔型、整数型、浮点型、复杂型、字符串型…..所以数组、切片、结构体不能作为key。
5. map的值可以是任意类型，可以通过使用空接口类型({}interfaces)，可以存储任何值，包括函数(可以用来做分支结构，key用来选择要执行的函数)

   含有数组切片的结构体不能作为key，只包含内建类型的struct是可以作为key的）,但是指针和接口类型可以。如果咬用结构体作为key，可以提供key()和Hash()方法，这样可以通过结构体的域计算出唯一的数组或者字符串的key。

1.2 Map的使用

1.1.1 创建map

map是引用类型，使用下面的结构进行声明

var map1 map[keytye]valuetype
示例：
var map1 map[string]int

具体示例：

// 初始化方法一，默认值是nil
var map1 map[string]int
map1 = map[string]int{"China": 1, "France": 2}
fmt.Println("map1：", map1)
var map2 = make(map[string]int)
map2["China"] = 1
map2["France"] = 2
fmt.Println("map2：", map2)
// 初始化方法二，默认值是nil
rating := map[string]float32{"C": 5, "GO": 4.5, "Python": 4.5, "C++": 2}
fmt.Println(rating)
// 初始化方法三
countryCapitalMap := make(map[string]string)
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "new Delhi"
fmt.Println(countryCapitalMap)
/*
    map1： map[China:1 France:2]
    map2： map[China:1 France:2]
    map[C:5 C++:2 GO:4.5 Python:4.5]
    map[France:Paris India:new Delhi Italy:Rome Japan:Tokyo]
*/

永远用make来构造map，不能使用new，如果错误的使用new()分配了一个对象，会获得一个空引用的指针，相当于声明了一个未初始化的变量，并且取了它的地址。

1.1.1.1 特例-使用函数作为值的map

func main() {
    userFuncAsArg()
}
func userFuncAsArg() {
    m := make(map[int]func())
    m[1] = f1
    m[2] = f2
    m[3] = f3
    fmt.Println(m)
    // 调用函数
    for i, v := range m {
        fmt.Print("索引是[", i, "] 内容是：")
        v()
    }
}
func f1() {
    fmt.Println("这是f1")
}
func f2() {
    fmt.Println("这是f2")
}
func f3() {
    fmt.Println("这是f3")
}
/*
    map[1:0x2a5ac0 2:0x2a5b60 3:0x2a5c00] //整形都被映射到函数地址。
    索引是[2] 内容是：这是f2
    索引是[3] 内容是：这是f3
    索引是[1] 内容是：这是f1
*/

1.1.1.2 用切片作为map的值

既然一个key只能对应一个value，而value又是一个原始类型，那么如果一个key要对应多个值怎么办？例如，当我们要处理unix机器上的所有进程，以父进程(pid为整形)作为key，所有的子线程(以所有子线程的pid组成的切片)作为value。通过将value定义为[]int类型或者其他类型的切片，就可以优雅的解决这个问题。
比如如下示例：

map1 := make(map[int][]int)
map2 := make(map[int]*[]int)

1.1.2 遍历map

使用range函数进行遍历

countryCapitalMap := make(map[string]string)
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "new Delhi"
fmt.Println(countryCapitalMap)
// 使用key输出map的值
for country := range countryCapitalMap {
    fmt.Println("Capital of", country, "is", countryCapitalMap[country])
}
// 也可以直接输出键值对
for k, v := range countryCapitalMap {
    fmt.Println(k, v)
}
/*
    map[France:Paris India:new Delhi Italy:Rome Japan:Tokyo]    
    Capital of France is Paris
    Capital of Italy is Rome
    Capital of Japan is Tokyo
    Capital of India is new Delhi
    Capital of United Stated is not present
    France Paris
    Italy Rome
    Japan Tokyo
    India new Delhi
*/

1.1.3 判断键是否存在

我们可以通过key获取map中对应的value值。语法为：

map[key]

但是当key如果不存在的时候，我们会得到该value值类型的默认值，比如string类型得到空字符串，int类型得到0。但是程序不会报错。
所以我们可以使用ok-idiom获取值，可知道key/value是否存在，语法为：

value, ok := map[key]

示例：

countryCapitalMap := make(map[string]string)
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "new Delhi"
fmt.Println(countryCapitalMap)
// 查看元素在集合中是否存在
capital, ok := countryCapitalMap["United States"]
if ok {
    fmt.Println("Capital of United Stated is", capital)
} else {
    fmt.Println("Capital of United Stated is not present")
}
/*
    map[France:Paris India:new Delhi Italy:Rome Japan:Tokyo]
    Capital of United Stated is not present        
*/

1.1.4 delete()函数

可以通过delete()函数，通过键名删除数据

countryCapitalMap := make(map[string]string)
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "new Delhi"
fmt.Println("原始 map")
for country := range countryCapitalMap {
    fmt.Println("Capital of", country, "is", countryCapitalMap[country])
}
// delete()函数
delete(countryCapitalMap, "France")
fmt.Println("删除元素后")
for country := range countryCapitalMap {
fmt.Println("Capital of", country, "is", countryCapitalMap[country])
}
/*
    原始 map
    Capital of France is Paris
    Capital of Italy is Rome
    Capital of Japan is Tokyo
    Capital of India is new Delhi
    删除元素后
    Capital of Italy is Rome
    Capital of Japan is Tokyo
    Capital of India is new Delhi
*/

1.1.5 获取map的长度

可以通过len()函数获取map的长度

countryCapitalMap := make(map[string]string)
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "new Delhi"
fmt.Println("原始 map")
fmt.Println("countryCapitalMap length is ", len(countryCapitalMap))
/*
    map[France:Paris India:new Delhi Italy:Rome Japan:Tokyo]
    countryCapitalMap length is  4
*/

1.1.6 map是引用类型

map是引用类型，当对map引用的对象进行修改时，因为都是指向相同的数据结构，所以原值也会发生变化

countryCapitalMap := make(map[string]string)
countryCapitalMap["France"] = "Paris"
countryCapitalMap["Italy"] = "Rome"
countryCapitalMap["Japan"] = "Tokyo"
countryCapitalMap["India"] = "new Delhi"
fmt.Println("countryCapitalMap原值是： ", countryCapitalMap)
newCountryCapitalMap := countryCapitalMap
newCountryCapitalMap["China"] = "Beijing"  // 新增
newCountryCapitalMap["France"] = "newParis" // 修改
fmt.Println("countryCapitalMap现值是：", countryCapitalMap)
/*
    countryCapitalMap原值是：  map[France:Paris India:new Delhi Italy:Rome Japan:Tokyo]
    countryCapitalMap现值是： map[China:Beijing France:newParis India:new Delhi Italy:Rome Japan:Tokyo]
*/

map不能使用==操作符进行比较。==只能用来检查map是否为空。否则会报错：invalid operation: map1 == map2 (map can only be comparedto nil)

1.1.7 map容量

和数组不同，map会根据新增的key-value对动态的伸缩，因此它不存在固定的长度或者最大限制。但是你也可以选择标名map的初始容量capacity，格式为：

make(map[keytype]valuetype,cap)

当map增长到容量上限的时候，如果再增加新的key-value对，map的大小会自动加1。所以出于性能的考虑，对于大的map或者会快速扩张的map，即使值是大概知道容量，也最好事先标明。

1.1.8 map类型的切片

假设我们想获取一个map类型的切片，我们必须使用两次make()函数，第一次分配切片，第二次分配切片中的每个元素。
示例：

func main() {
    mapStyleSlice()
}
// --------------------------map类型的切片---------------------
func mapStyleSlice() {
    items := make([] map[int]string, 5) // 分配长度为5的切片
    for index := range items {
        // 通过索引获取切片，然后给该切片分配map元素
        items[index] = make(map[int]string, 1)
        items[index][1] = "test"
    }
    fmt.Printf("Version A:value of items:%v\n", items)
}
/*
    Version A:value of items:[map[1:test] map[1:test] map[1:test] map[1:test] map[1:test]]
*/

1.1.9 map的排序

map默认是无序的，不管是按照key还是按照value默认都是不排序的。
如果想要map排序，需要将key(或者value)拷贝到一个切片，再对切片排序(使用sort包 )，然后再通过遍历切片通过key获取值。

1.1.9.1 通过key进行排序

func main() {
    mapSortByKey()
}
func mapSortByKey() {
    countryMap := make(map[string]int, 3)
    countryMap["D"] = 3
    countryMap["A"] = 2
    countryMap["C"] = 1
    fmt.Println("countryMap未排序前：")
    for key, value := range countryMap {
        fmt.Println("key是[", key, "] 值是：", value)
    }
    // 想要排序，需要将key或者value拷贝到一个切片，在进行切片排序，然后循环
    // 这里通过key进行排序
    keys := make([]string, len(countryMap))
    index := 0 // 从索引0开始设置值
    for key, _ := range countryMap {
        keys[index] = key // 将key放入切片
        index++           // 索引自增
    }
    fmt.Println("键名keys未排序前", keys)
    sort.Strings(keys)
    fmt.Println("键名keys排序后", keys)
    fmt.Println("countryMap排序后：")
    for _, k := range keys { // 遍历排序后的键
        fmt.Println("key是[", k, "] 值是：", countryMap[k])
    }
}
/*
    countryMap未排序前：
    key是[ D ] 值是： 3
    key是[ A ] 值是： 2
    key是[ C ] 值是： 1
    键名keys未排序前 [C D A]
    键名keys排序后 [A C D]
    countryMap排序后：
    key是[ A ] 值是： 2
    key是[ C ] 值是： 1
    key是[ D ] 值是： 3
*/

1.1.9.2 通过value进行排序

func main() {
    mapSortByValue()
}
// --------------------------map通过value排序----------------------
func mapSortByValue() {
    countryMap := make(map[string]int, 3)
    countryMap["D"] = 33
    countryMap["A"] = 65
    countryMap["C"] = 21
    countryMap["E"] = 8
    countryMap["F"] = 44
    fmt.Println("countryMap未排序前：")
    for key, value := range countryMap {
        fmt.Println("key是[", key, "] 值是：", value)
    }
    values := make([]int, len(countryMap))
    index := 0
    for _, value := range countryMap {
        values[index] = value
        index++
    }
    fmt.Println("值values未排序前 ", values)
    sort.Ints(values)
    fmt.Println("值values未排序后 ", values)
    fmt.Println("countryMap排序后：")
    for _, v := range values {
        for key, value := range countryMap {
            if v == value {
                fmt.Println("key是[", key, "] 值是：", value)
            }
        }
    }
}
/*
    countryMap未排序前：
    key是[ D ] 值是： 33
    key是[ A ] 值是： 65
    key是[ C ] 值是： 21
    key是[ E ] 值是： 8
    key是[ F ] 值是： 44
    值values未排序前  [21 8 44 33 65]
    值values未排序后  [8 21 33 44 65]
    countryMap排序后：
    key是[ E ] 值是： 8
    key是[ C ] 值是： 21
    key是[ D ] 值是： 33
    key是[ F ] 值是： 44
    key是[ A ] 值是： 65
*/

1.1.9.3 通过结构体和切片进行排序

综述上面两个示例可以得出，如果想要一个排序的列表，最好是使用类似下面的结构体切片，这样会比较有效。

type name struct{
    key string
    value int
}

需要注意的是，定义的结构体需要有对应的结构体函数（Len()、Swap()、Less()），才能进行比较，下面是一个通过value进行排序的示例：
如果想通过key进行排序，只需要修改less()方法中的return逻辑即可，下列代码有提示。

type country struct {
    key   string
    value int
}
type countrySlice []country
func (cs countrySlice) Len() int {
    return len(cs)
}
func (cs countrySlice) Swap(i, j int) {
    cs[i], cs[j] = cs[j], cs[i]
}
func (cs countrySlice) Less(i, j int) bool {
    // 这里是比较value进行排序的，如果想通过key进行排序只需要修改下面的代码为 return cs[i].key < cs[j].key
    return cs[i].key < cs[j].key
}
func main() {
    mapSortByStructSlice()
}
// --------------------------使用结构体切片进行排序-----------------
func mapSortByStructSlice() {
    countrySlice := make(countrySlice, 4)
    countrySlice[0] = country{"D", 1}
    countrySlice[1] = country{"A", 2}
    countrySlice[2] = country{"C", 4}
    countrySlice[3] = country{"B", 3}
    fmt.Println("未排序前country ", countrySlice)
    sort.Sort(countrySlice)
    fmt.Println("通过value排序后country ", countrySlice)
}
/*
    未排序前country  [{D 1} {A 2} {C 4} {B 3}]
    通过value排序后country  [{D 1} {A 2} {B 3} {C 4}]
*/

1.1.10 map键值对调

这里说的是调换key和value。如果map的值类型可以作为key且所有的value是唯一的，那么可以通过下面的方法进行简单的简直对调。

func main() {
    kvReverse()
}
// --------------------------将map的键值对调----------------------
func kvReverse() {
    countryMap := make(map[string]int, 3)
    countryMap["D"] = 33
    countryMap["A"] = 65
    countryMap["C"] = 21
    countryMap["E"] = 8
    countryMap["F"] = 44
    fmt.Println("未反转的值：", countryMap)
    reverseMap := make(map[int]string, len(countryMap))
    for k, v := range countryMap {
        reverseMap[v] = k
    }
    fmt.Println("反转的值：", reverseMap)
}
/*
    未反转的值： map[A:65 C:21 D:33 E:8 F:44]
    反转的值： map[8:E 21:C 33:D 44:F 65:A]
*/