Golang 映射（map） - Golang教程网

1. 什么是 map

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值
Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的
Map 是引用类型，必须初始化才能使用。其中，key的类型除了切片等引用类型，其他类型都可以；而value则可使用所有类型的值

2. 创建 map

make()

my_map := make(map[string]int)

[string]表示map的key的数据类型
int表示key对应的值

直接通过大括号创建并初始化赋值：

// 空map
my_map := map[string]string{}

// 初始化赋值
my_map := map[string]string{"Red": "#da1337","Orange": '#e95a22"}

// 格式化赋值
my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,      // 注意结尾的逗号不能少
			}

注意：

==

my_map := map[string][]int{}

3. 访问 map

访问map中的元素时，指定它的key即可，注意string类型的key必须加上引号：

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 10,
		"2": 20,
		"3": 30,
		"4": 40,
	}

	//访问
	fmt.Println(my_map["1"])
	fmt.Println(my_map)

	fmt.Println("")

	//赋值已有的key & value
	my_map["2"] = 50
	fmt.Println(my_map["2"])
	fmt.Println(my_map)

	fmt.Println("")

	//赋值新的key&value
	my_map["5"] = 66
	fmt.Println(my_map["5"])
	fmt.Println(my_map)
}


//输出结果
10
map[1:10 2:20 3:30 4:40]

50
map[1:10 2:50 3:30 4:40]

66
map[1:10 2:50 3:30 4:40 5:66]

4. nil map和空map

空map是不做任何赋值的map：

// 空map
package main

import "fmt"

func main() {
	my_map := map[string]string{}

	fmt.Println(my_map)
}

//输出结果
map[]

nil map，它将不会做任何初始化，不会指向任何数据结构：

// nil map
var my_map map[string]string

nil map和empty map的关系，就像nil slice和empty slice一样，两者都是空对象，未存储任何数据，但前者不指向底层数据结构，后者指向底层数据结构，只不过指向的底层对象是空对象。

使用println输出看下即可知道：

package main

func main() {
	var nil_map map[string]string
	println(nil_map)

	emp_map := map[string]string{}
	println(emp_map)
}

输出结果：

0x0
0xc04204de38

所以，map类型实际上就是一个指针。

5. map中元素的返回值

当访问map中某个元素的时候，有两种返回值的格式：

value := my_map["key"]
value,exists := my_map["key"]

第一种很好理解，就是检索map中key对应的value值。如果key不存在，则value返回值对应数据类型的0。例如int为数值0，布尔为false，字符串为空""。

第二种不仅返回key对应的值，还根据key是否存在返回一个布尔值赋值给exists变量。所以，当key存在时，value为对应的值，exists为true；当key不存在，value为0(同样是各数据类型所代表的0)，exists为false。

看下例子：

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 10,
		"2": 20,
		"3": 30,
		"4": 40,
	}
	a := my_map["1"]
	b, exists1 := my_map["2"]
	c, exists2 := my_map["5"]
	fmt.Println(a)
	fmt.Println(b, exists1)
	fmt.Println(c, exists2)
}

上面将输出如下结果：

10
20 true
0 false

在Go中设置类似于这种多个返回值的情况很多，即便是自己编写函数也会经常设置它的exists属性。

6. len()和delete()

len()函数delete()

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 10,
		"2": 20,
		"3": 30,
		"4": 40,
	}

	fmt.Printf("删除前长度为%d\n", len(my_map))
	delete(my_map, "1")
	fmt.Printf("删除后长度为%d", len(my_map))
}

//输出结果如下
删除前长度为4
删除后长度为3

7. 测试map中元素是否存在

两种方式可以测试map中是否存在某个key：

① 根据map元素的第二个返回值来判断
② 根据返回的value是否为0(不同数据类型的0不同)来判断

方式一：直接访问map中的该元素，将其赋值给两个变量，第二个变量就是元素是否存在的修饰变量。

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 10,
		"2": 20,
		"3": 30,
		"4": 40,
	}
	
//方法1
/* value, exists := my_map["1"]
	if exists {
		fmt.Println("存在", value)
	}
 */


	//方法2
	if value, exists := my_map["1"]; exists {
		fmt.Printf("值存在, value=%d", value)
	}
}

//输出结果如下
值存在, value=10

方式二：根据map元素返回的value判断。因为该map中的value部分是int类型，所以它的0是数值的0。

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 10,
		"2": 20,
		"3": 30,
		"4": 40,
	}

	value := my_map["5"]
	if value == 0 {
		fmt.Println("不存在")
	}
}


//输出结果如下
不存在

如果map的value数据类型是string，则判断是否为空：

package main

import "fmt"

func main() {
	my_map := map[string]string{
		"1": "book",
		"2": "games",
		"3": "computer",
	}

	value := my_map["5"]
	if value == "" {
		fmt.Println("不存在")
	}
}

//输出结果如下
不存在

由于map中的value有可能本身是存在的，但它的值为0，这时就会出现误判断。例如下面的"3"，它已经存在，但它对应的值为0

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 22,
		"2": 11,
		"3": 0,
	}

	value := my_map["3"]
	if value == 0 {
		fmt.Println("不存在")
	}
}

//输出结果如下
不存在

所以，应当使用第一种方式进行判断元素是否存在。

8. 迭代遍历 map

因为map是key/value类型的数据结构，key就是map的index，所以range关键字对map操作时，将返回key和value。

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 22,
		"2": 11,
		"3": 0,
		"4": 55,
		"5": 66,
	}

	for k, v := range my_map {
		fmt.Printf("key=%s, value=%d\n", k, v)
	}
}


//输出结果如下
key=1, value=22
key=2, value=11
key=3, value=0
key=4, value=55
key=5, value=66

如果range迭代map时，只给一个返回值，则表示迭代map的key：

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 22,
		"2": 11,
		"3": 0,
		"4": 55,
		"5": 66,
	}

	for key := range my_map {
		fmt.Println("key=", key)
	}
}


//输出结果
key= 1
key= 2
key= 3
key= 4
key= 5

9. 获取map中所有的key

Go中没有提供直接获取map所有key的函数。所以，只能自己写，方式很简单，range遍历map，将遍历到的key放进一个slice中保存起来。

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
		"Shell":  23,
	}

    // 保存map中key的slice
    // slice类型要和map的key类型一致
	keys := make([]string,0,len(my_map))

    // 将map中的key遍历到keys中
	for map_key,_ := range my_map {
		keys = append(keys,map_key)
	}

	fmt.Println(keys)
}

注意上面声明的slice中要限制长度为0，否则声明为长度4、容量4的slice，而这4个元素都是空值，而且后面append()会直接对slice进行一次扩容，导致append()后的slice长度为map长度的2倍，前一半为空，后一般才是map中的key。

10. 传递map给函数

map是一种指针，所以将map传递给函数，仅仅只是复制这个指针，所以函数内部对map的操作会直接修改外部的map。

例如，test()用于给map的key对应的值加1。

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"1": 22,
		"2": 11,
		"3": 0,
		"4": 55,
		"5": 66,
	}
	fmt.Println("修改之前key=", my_map["3"])
	fmt.Println(my_map)

	fmt.Println("")

	test(my_map, "3")
	fmt.Println("修改之后key=", my_map["3"])
	fmt.Println(my_map)

}

func test(m map[string]int, key string) {
	m[key] += 1
}


//输出结果如下
修改之前key= 0
map[1:22 2:11 3:0 4:55 5:66]

修改之后key= 1
map[1:22 2:11 3:1 4:55 5:66]

总结

key:value哈希表