14、Map

1.Map的定义

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

使用map过程中需要注意的几点:

• map是无序的，每次打印出来的map都会不一样，它不能通过index获取，而必须通过key获取。map的长度是不固定的，也就是和slice一样，也是一种引用类型。内置的len函数同样适用于map，返回map拥有的key的数量
• map的key可以是所有可比较的类型，如布尔型、整数型、浮点型、复杂型、字符串型.....也可以键。

2.Map的使用

/**
 * @author ly (个人博客:https://www.cnblogs.com/qbbit)
 * @date 2023/4/10  20:31
 * @tags 喜欢就去努力的争取
 */
package main

import "fmt"

func main() {

	/**
	方式一:var map1 map[key类型]value类型
	*/
	var map1 map[int]string

	/**
	方式二:var map2 = make(map[key类型]value类型)
	*/
	var map2 = make(map[int]string)

	/**
	方式三:var map3 = make[key类型]value类型{k1:v1,k2:v3,......}
	*/
	var map3 = map[string]int{"Go": 99, "Java": 98, "Python": 97}
	map4 := map[int]int{1: 100, 2: 200, 3: 300}

	fmt.Println(map1)
	fmt.Println(map2)
	fmt.Println(map3)
	fmt.Println(map4)

	// 如果不初始化 map，那么就会创建一个nil map。nil map不能用来存放键值对
	// 这个nil --> 就相当于null
	if map1 == nil {
		map1 = make(map[int]string)
		fmt.Println(map1 == nil)
	}
}

map的存储特点

• 存储的是无序的键值对
• 键不能重复，并且和value值一一对应的：map的key不能重复，如果重复了，那么新的value会覆盖原来的，程序不会报错

3.map的一些基本操作

map1[1] = "hello"
	map1[2] = "world"
	map1[3] = "ly"
	map1[4] = "王二狗"
	map1[5] = "ruby"
	map1[6] = "Javascript"
	map1[7] = ""

	fmt.Println(map1)
	fmt.Println(map1[3])
	fmt.Println(map1[40])

	// 1、获取数据，根据key获取对应的value值
	// 根据key获取对应的value，如果key存在，获取数值，如果key不存在，获取的是value值类型的零值
	val := map1[1]
	fmt.Println(val)
	// 推荐下面的方式进行获取数据，ok可以进行判断
	v1, ok := map1[40]
	if ok {
		fmt.Println("对应的数值为：", v1)
	} else {
		fmt.Println("操作的key不存在，获取到的是零值：", v1)
	}

	// 2、添加|修改数据
	// key存在修改，key不存在添加
	map1[7] = "ly"
	fmt.Println(map1)

	// 3、删除数据
	delete(map1, 2)
	fmt.Println(map1)

	// 4、map的长度
	fmt.Println("map的长度为：", len(map1))
	// fmt.Println("map的容量为：",cap(map1)) // 错误写法

4.map的遍历

/**
	map的遍历
		使用:for range
			数组，切片：index,value
			map: key，value
	*/
	for key, value := range map1 {
		fmt.Printf("key:%d , value:%s \n", key, value)
	}

	for _, value := range map1 {
		fmt.Println("value:", value)
	}

	// 创建一个切片
	keys := make([]int, 0, len(map1))
	fmt.Println("keys:", keys)

	// 遍历map
	for k, _ := range map1 {
		keys = append(keys, k)
	}
	fmt.Println(keys)

	// 排序
	sort.Ints(keys)
	fmt.Println(keys)

	// 这样就可以顺序的拿到map中的值了
	for _, key := range keys {
		fmt.Println(key, map1[key])
	}

	// 字符串的排序
	s1 := []string{"App", "windows", "Orange", "abc", "acd", "acc", "宝宝"}
	fmt.Println(s1)
	sort.Strings(s1)
	fmt.Println(s1)

5.map和slice的使用

// map和slice结合使用
	mapA := make(map[string]string)
	mapA["name"] = "zs"
	mapA["age"] = "18"
	mapA["address"] = "湖北武汉"

	mapB := make(map[string]string)
	mapB["name"] = "ly"
	mapB["age"] = "20"
	mapB["address"] = "湖北黄石"

	sl := make([]map[string]string, 0, 2)
	sl = append(sl, mapA)
	sl = append(sl, mapB)
	fmt.Println(sl)

	for index, m := range sl {
		fmt.Println(index, m["name"], m["age"], m["address"])
	}

6.map是引用类型

// map是引用类型
	mapC := make(map[string]float64)
	mapD := make(map[int]int64)
	fmt.Printf("%T\n", mapC)
	fmt.Printf("%T\n", mapD)

	mapE := make(map[string]map[int]string)
	fmt.Printf("%T\n", mapE)

	m1 := make(map[int]string)
	m1[1] = "a"
	m1[2] = "b"

	m2 := make(map[int]string)
	m2[1] = "ly"
	m2[2] = "bao"

	mapE["A"] = m1
	mapE["B"] = m2

	fmt.Println(mapE)

	// 验证map是引用类型
	mapF := mapE

	fmt.Println(mapE)
	fmt.Println(mapF)

	m3 := map[int]string{1: "zs", 2: "包"}
	mapF["A"] = m3

	// 验证
	fmt.Println(mapE)
	fmt.Println(mapF)