Go 学习笔记(八)map 类型

本文原创地址:博客园骏马金龙Go 基础系列:map 类型

Go 里的 map 用于存放 key/value 对,在其它地方常称为 hash、dictionary、关联数组,这几种称呼都是对同一种数据结构的不同称呼,它们都用于将 key 经过 hash 函数处理,然后映射到 value,实现一一对应的关系。

map 的内部结构

一个简单的 map 结构示意图:

1.png

在向 map 中存储元素的时候,会将每个 key 经过 hash 运算,根据运算得到的 hash 值选择合适的 hash bucket(hash 桶),让后将各个 key/value 存放到选定的 hash bucket 中。如果一来,整个 map 将根据 bucket 被细分成很多类别,每个 key 可能会交叉地存放到不同的 bucket 中。

所以,map 中的元素是无序的,遍历时的顺序是随机的,即使两次以完全相同的顺序存放完全相同的元素,也无法保证遍历时的顺序。

由于要对 key 进行 hash 计算选择 hash bucket,所以 map 的 key 必须具有唯一性,否则计算出的 hash 值相同,将人为出现 hash 冲撞。

在访问、删除元素时,也类似,都要计算 key 的 hash 值,然后找到对应的 hash bucket,进而找到 hash bucket 中的 key 和 value。

Go 中的 map 是一个指针,它的底层是数组,而且用到了两个数组,其中一个更底层的数组用于打包保存 key 和 value。

创建、访问 map

可以通过 make() 创建 map,它会先创建好底层数据结构,然后再创建 map,并让 map 指向底层数据结构。

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,      // 注意结尾的逗号不能少
			}

其中 map 的 key 可以是任意内置的数据类型 (如 int),或者其它可以通过 "==" 进行等值比较的数据类型,如 interface 和指针可以。slice、数组、map、struct 类型都不能作为 key。

但 value 基本可以是任意类型,例如嵌套一个 slice 到 map 中:

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

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

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
			}

// 访问
println(my_map["Perl"])

// 赋值已有的key & value
my_map["Perl"] = 12
println(my_map["Perl"])

// 赋值新的key & value
my_map["Shell"] = 14
println(my_map["Shell"])

nil map 和空 map

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

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

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 类型实际上就是一个指针

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

看下例子:

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
			}

value1 := my_map["Python"]
value2,exists2 := my_map["Perl"]
value3,exists3 := my_map["Shell"]

println(value1)
println(value2,exists2)
println(value3,exists3)

上面将输出如下结果:

13
8 true
0 false

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

len()和 delete()

len()函数用于获取 map 中元素的个数,即有多个少 key。delete() 用于删除 map 中的某个 key。

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

	println(len(my_map))    // 4

	delete(my_map,"Perl")

	println(len(my_map))    // 3
}

测试 map 中元素是否存在

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

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

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

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
			}

value,exists := my_map["Perl"]

if exists {
	println("The key exists in map")
}

可以将上面两个步骤合并起来,看着更高大上一些:

if value,exists := my_map["Perl"];exists {
	println("key exists in map")
}

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

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
			}

value := my_map["Shell"]
if value == 0 {
	println{"not exists in map"}
}

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

if value == "" {
	println("not exists in map")
}

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

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
				"Shell":0,
			}

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

迭代遍历 map

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

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

for key,value := range my_map {
	println("key:",key," value:",value)
}

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

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

for key := range my_map {
	println("key:",key)
}

获取 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。

传递 map 给函数

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

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

package main

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

	println(my_map["Perl"])   // 8
	addone(my_map,"Perl") 
	println(my_map["Perl"])   // 9
}

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

使用函数作为 map 的值

map 的值可以是任意对象,包括函数、指针、stuct 等等。如果将函数作为 key 映射的值,则可以用于实现一种分支结构。

map_func := map[KEY_TYPE]func() RETURN_TYPE {......}
map_func := make(map[KEY_TYPE]func() RETURN_TYPE)

例如:

func main() {
	mf := map[int]func() int{
		1: func() int { return 10 },
		2: func() int { return 20 },
		5: func() int { return 50 },
	}
	fmt.Println(mf)  // 输出函数的指针
	a := mf[1]()     // 调用某个分支的函数
	println(a)
}

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

	fmt.Println(mf[2]())
}