Go基础系列：map类型

时间 2019-11-06

标签基础系列 map 类型繁體版

原文原文链接

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

map的内部结构

一个简单的map结构示意图：数据结构

在向map中存储元素的时候，会将每一个key通过hash运算，根据运算获得的hash值选择合适的hash bucket(hash桶)，让后将各个key/value存放到选定的hash bucket中。若是一来，整个map将根据bucket被细分红不少类别，每一个key可能会交叉地存放到不一样的bucket中。app

因此，map中的元素是无序的，遍历时的顺序是随机的，即便两次以彻底相同的顺序存放彻底相同的元素，也没法保证遍历时的顺序。函数

因为要对key进行hash计算选择hash bucket，因此map的key必须具备惟一性，不然计算出的hash值相同，将人为出现hash冲撞。测试

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

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

建立、访问map

能够经过make()建立map，它会先建立好底层数据结构，而后再建立map，并让map指向底层数据结构。对象

my_map := make(map[string]int)

其中[string]表示map的key的数据类型，int表示key对应的值。blog

也能够直接经过大括号建立并初始化赋值：字符串

// 空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：

根据map元素的第二个返回值来判断
根据返回的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的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]())
}