Go_map

1. map的创建和使用

key不能是引用类型，key要求是不变的，引用类型的地址不变，但是值会改变

package main

import "fmt"

func main() {
	/*
	map：映射，是一种专门用于存储键值对的集合。属于引用类型

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

	语法结构：
		1.创建map
			var map1 map[key类型]value类型 //nil map，无法直接使用

			var map2 = make(map[key类型]value类型)

			map3 := make(map[key类型]value类型)
　　　　　　　　　　　　　　　　　　　　　
　　　　　　 //不写make直接赋值，底层有make
			var map3 = map[key类型]value类型{key:value,key:value,key:value...}

			map5 := map[key类型]value类型{key:value,key:value,key:value...}


		2.添加/修改
			map[key]=value
				如果key不存在，就是添加数据
				如果key存在，就是修改数据

		3.获取
			map[key]-->value

			value,ok := map[key]
				根据key获取对应的value
					如果key存在，value就是对应的数据，ok为true
					如果key不存在，value就是值类型的默认值，ok为false

		4.删除数据：
			delete(map，key)
				如果key存在，就可以直接删除
				如果key不存在，删除失败，不会报错

		5.长度：
			len()



	每种数据类型：
		int：0
		float：0.0-->0
		string:""
		array:[00000]

		slice：nil
		map：nil

	 */

	//1.创建map
	var map1 map[int]string         //没有初始化，nil
	var map2 = make(map[int]string) //创建
	var map3 = map[string]int{"Go": 98, "Python": 87, "Java": 79, "Html": 93}
	fmt.Println(map1) //map[]
	fmt.Println(map2) //map[]
	fmt.Println(map3) //map[Go:98 Html:93 Java:79 Python:87]

	fmt.Println(map1 == nil) //true
	fmt.Println(map2 == nil) //false
	fmt.Println(map3 == nil) //false
	//2.nil map
	if map1 == nil {
		map1 = make(map[int]string)
		fmt.Println(map1 == nil) //false
	}
	//3.存储键值对到map中
	//map1[key] = value
	map1[1] = "hello" //panic: assignment to entry in nil map
	map1[2] = "world"
	map1[3] = "memeda"
	map1[4] = "王二狗"
	map1[5] = "ruby"
	map1[6] = "三胖思密达"
	map1[7] = ""

	//4.获取数据，根据key获取对应的value值
	//根据key获取对应的value，如果key存在，获取数值，如果key不存在，获取的是value值类型的零值
	fmt.Println(map1) //map[1:hello 2:world 3:memeda 4:王二狗 5:ruby 6:三胖思密达 7:]
	fmt.Println(map1[4]) //王二狗
	fmt.Println(map1[40]) //""

	v1,ok :=map1[40]
	if ok {
		fmt.Println("对应的数值是：",v1)
	}else{
		fmt.Println("操作的key不存在，获取到的是零值：",v1)
	}

	//5.修改数据
	fmt.Println(map1)
	map1[3] = "如花"
	fmt.Println(map1)

	//6.删除数据
	delete(map1,3)
	fmt.Println(map1)
	delete(map1,100)
	fmt.Println(map1)

	//7.长度
	fmt.Println(len(map1))


}

2. map的遍历

package main

import (
	"fmt"
	"sort"
)

func main() {
	/*
	map的遍历：
		使用：for range

			数组，切片：index，value
			map：key，value
	 */
	map1 := make(map[int]string)
	map1[1] = "红孩儿"
	map1[2] = "小钻风"
	map1[3] = "白骨精"
	map1[4] = "白素贞"
	map1[5] = "金角大王"
	map1[6] = "王二狗"

	//1.for range遍历map
	for k, v := range map1 {
		fmt.Println(k, v)
	}

	//2.for遍历map
	for i := 1; i <= len(map1); i++ {
		fmt.Println(i, "--->", map1[i])
	}
	/*
	1.获取所有的key，-->切片/数组
	2.进行排序
	3.遍历key，--->map[key]
	 */
	keys := make([]int, 0, len(map1))
	fmt.Println(keys)

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

	//冒泡排序，或者使用sort包下的排序方法
	sort.Ints(keys)
	fmt.Println(keys)

	for _, key := range keys {
		fmt.Println(key, map1[key])
	}

	s1 := []string{"Apple", "Windows", "Orange", "abc", "王二狗", "acd", "acc"}
	fmt.Println(s1) //[Apple Windows Orange abc 王二狗 acd acc]
	sort.Strings(s1)
	fmt.Println(s1) //[Apple Orange Windows abc acc acd 王二狗]
}

3. map和slice的结合使用

package main

import "fmt"

func main() {
	/*
	map和slice的结合使用：
		1.创建map用于存储人的信息
			name，age，sex，address

		2.每个map存储一个人的信息

		3.将这些map存入到slice中

		4.打印遍历输出
	 */

	//1.创建map存储第一个人的信息
	map1 := make(map[string]string)
	map1["name"] = "王二狗"
	map1["age"] = "30"
	map1["sex"] = "男性"
	map1["address"] = "北京市XX路XX号"
	fmt.Println(map1) //map[address:北京市XX路XX号 age:30 name:王二狗 sex:男性]

	//2.第二个人
	map2 := make(map[string]string)
	map2["name"] = "李小花"
	map2["age"] = "20"
	map2["sex"] = "女性"
	map2["address"] = "上海市。。。"
	fmt.Println(map2) //map[address:上海市。。。 age:20 name:李小花 sex:女性]

	map3 := map[string]string{"name": "ruby", "age": "30", "sex": "女性", "address": "杭州市"}
	fmt.Println(map3) //map[address:杭州市 age:30 name:ruby sex:女性]

	//将map存入到slice中
	s1 := make([]map[string]string, 0, 3)
	s1 = append(s1, map1)
	s1 = append(s1, map2)
	s1 = append(s1, map3)

	//遍历切片
	for i, val := range s1 {
		//val ：map1，map2，map3
		fmt.Printf("第 %d 个人的信息是：
", i+1)
		fmt.Printf("	姓名：%s
", val["name"])
		fmt.Printf("	年龄：%s
", val["age"])
		fmt.Printf("	性别：%s
", val["sex"])
		fmt.Printf("	地址：%s
", val["address"])
	}
}
/*
第 1 个人的信息是：
	姓名：王二狗
	年龄：30
	性别：男性
	地址：北京市XX路XX号
第 2 个人的信息是：
	姓名：李小花
	年龄：20
	性别：女性
	地址：上海市。。。
第 3 个人的信息是：
	姓名：ruby
	年龄：30
	性别：女性
	地址：杭州市
*/

4. map是引用类型

package main

import "fmt"

func main() {
	/*
	一：数据类型：
		基本数据类型：int，float，string，bool
		复合数据类型：array，slice，map，function，pointer，struct。。。

			array：[size]数据类型
			slice：[]数据类型
			map：map[key的类型]value的类型


	二：存储特点：
		值类型：int，float，string，bool，array，struct
		引用类型：slice，map

			make()，slice，map，chan


	 */

	map1 := make(map[int]string)
	map2 := make(map[string]float64)
	fmt.Printf("%T
", map1) //map[int]string
	fmt.Printf("%T
", map2) //map[string]float64

	map3 := make(map[string]map[string]string) //map[string]map[string]string
	m1 := make(map[string]string)
	m1["name"] = "王二狗"
	m1["age"] = "30"
	m1["salary"] = "3000"
	map3["hr"] = m1

	m2 := make(map[string]string)
	m2["name"] = "ruby"
	m2["age"] = "28"
	m2["salary"] = "8000"
	
	//把一个map赋值给一个map中的键
	map3["总经理"] = m2
	fmt.Println("map3", map3)
	//map3 map[hr:map[age:30 name:王二狗 salary:3000] 总经理:map[age:28 name:ruby salary:8000]]

	map4 := make(map[string]string)
	map4["王二狗"] = "矮矬穷"
	map4["李小花"] = "白富美"
	map4["ruby"] = "住在隔壁"
	fmt.Println(map4) //map[ruby:住在隔壁 李小花:白富美 王二狗:矮矬穷]

	map5 := map4
	fmt.Println(map5) //map[ruby:住在隔壁 李小花:白富美 王二狗:矮矬穷]

	map5["王二狗"] = "高富帅"
	fmt.Println(map4) //map[ruby:住在隔壁 李小花:白富美 王二狗:高富帅]
	fmt.Println(map5) //map[ruby:住在隔壁 李小花:白富美 王二狗:高富帅]

}