什么是map?

在go中，map是将值(key)和建(value)关联的内置类型，通过相应的键可以获取到值。

声明：

func main() {
	var mapList map[string]int
	//fmt.Println(mapList)
	if mapList == nil {
		fmt.Println(mapList)
	}
}
// 声明 
// key 是 string类型 
// value 是 类型 
// 变量名 mapList 的 map 
// 此时的mapList 是空的，默认值是 nil 

初始化/创建：

// 声明后是无法使用的 
// 添加key-value 会报异常
func main() {
	var mapList map[string]int
	mapList["a"] = 1
	mapList["b"] = 2
	mapList["c"] = 3
	fmt.Println(mapList)
}
// 输出：panic: assignment to entry in nil map
// 需要make去创建该map,也可以理解成初始化
func main() {
	var mapList map[string]int
    if mapList == nil{
        mapList = make(map[string]int)
    }
	mapList["a"] = 1
	mapList["b"] = 2
	mapList["c"] = 3
	fmt.Println(mapList)
}
// 输出：map[a:1 b:2 c:3]
// 测试
func main() {
	var mapList map[string]int
	if mapList == nil{
		mapList = make(map[string]int)
	}
	mapList[""] = 1	// "" 空字符也算一个元素
	mapList[""] = 4	 // 重复会覆盖，上一个
	mapList["a"] = 2 
	mapList["a"] = 5 // 重复会覆盖，上一个
	mapList["c"] = 3 
	fmt.Println(mapList)
}
// 输出：map[:4 a:5 c:3]

创建时初始化

// 声明时初始化
mapListTwo := map[string]int{
    "string":100,
    "":110,
    "go":120,
}
fmt.Println(mapListTwo)

获取元素

// 获取元素
str := mapList["a"]
fmt.Println(str,mapList[""],mapList["66"])
// 输出：5 4 0
// 当获取元素是map不存在拿到的就是value类型的默认值
// 声明时初始化
mapListTwo := map[string]string{
    "string":"100",
    "":"110",
    "go":"120",
}
mapListOne := map[string]int{
    "string":100,
    "":110,
    "go":120,
}
// 获取元素
str := mapListTwo["a"]
if str == "" {
    fmt.Println("str :",str )
}
stri := mapListOne["a"]
if stri == 0 {
    fmt.Println("stri :",stri )
}
// 输出：str : 
// 输出：stri : 0

判断元素是否存在map中

// 判断一个元素是否存在map中
func main()  {
	mapListOne := map[string]int{
		"string":100,
		"":110,
		"go":120,
	}
	// 判断一个元素是否存在map中
	value,ok := mapListOne["string"]
	if ok == true {
		fmt.Println("string : ",value,ok)
	}
	values,oks := mapListOne["java"]
	if oks {
		fmt.Println("java is ture: ",values,oks)
	} else {
		fmt.Println("java is false: ",values,oks)
	}
}
// 输出：
// string is true:  100 true
// java is false:  0 false

遍历map中的所有元素：for range （使用时不能保证每次执行程序获取的元素顺序都相同）

func main()  {
    // 声明&初始化 mapList
	var mapList map[string]int
	mapList = make(map[string]int)
	mapList["string"] = 100
	mapList["java"] = 200
	mapList["go"] = 300
	// 声明初始化 simpleMap
	simpleMap := map[string]string{
		"JSON":"JSON",
		"java":"java",
	}
    // 遍历 map   (key,value,ok|遍历和判断是否存在元素) 
	for key,value := range simpleMap {
		fmt.Printf("simpleMap[%s] = %s \n",key,value)
	}
	for key,value := range mapList {
		fmt.Printf("mapList[%s] = %d \n",key,value)
	}
}
// 输出两次执行结果：
// simpleMap[JSON] = JSON 		simpleMap[JSON] = JSON
// simpleMap[java] = java 		simpleMap[java] = java 
// mapList[string] = 100 		mapList[java] = 200 
// mapList[java] = 200 			mapList[go] = 300
// mapList[go] = 300 			mapList[string] = 100 

删除map中的元素

func main()  {
	//删除map中的元素
	mapList := map[string]int{
		"string":1000,
		"go":2000,
		"map":3000,
	}
	fmt.Println("mapList all ",mapList," length is ",len(mapList))
	delete(mapList,"map")
	fmt.Println("mapList deletion all ",mapList,"length is ",len(mapList))
}
// 输出:
// mapList all  map[go:2000 map:3000 string:1000]  length is  3
// mapList deletion all  map[go:2000 string:1000] length is  2

map 是引用类型，对map元素的改变即在改变这个map，且这个修改是显性的。
map 类型之间不能使用 ==符判断，==是能用来判断该map是否初始化为nil。
map声明后必须要初始化才可以使用。
key必须是支持==或!=比较运算的类型(其类型的默认值也可以当作一个key)，不可以是函数、map或slice。
使用for range 遍历时是无序的