继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

Go基础系列:map类型

智慧大石
关注TA
已关注
手记 337
粉丝 33
获赞 206

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

map的内部结构

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

5c162ba500011b1203850274.jpg

在向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对应的值。

也可以直接通过大括号创建并初始化赋值:

1
2
3
4
5
6
7
8
9
10
11
12// 空mapmy_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必须加上引号:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16my_map := map[string]int{                "Java":11,                "Perl":8,                "Python":13,
            }// 访问println(my_map["Perl"])// 赋值已有的key & valuemy_map["Perl"] = 12println(my_map["Perl"])// 赋值新的key & valuemy_map["Shell"] = 14println(my_map["Shell"])

nil map和空map

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

1
2// 空mapmy_map := map[string]string{}

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

1
2// nil mapvar my_map map[string]string

nil map和empty map的关系,就像nil slice和empty slice一样,两者都是空对象,未存储任何数据,但前者不指向底层数据结构,后者指向底层数据结构,只不过指向的底层对象是空对象。使用println输出看下即可知道:

1
2
3
4
5
6
7
8
9package mainfunc main() {    var nil_map map[string]string
    println(nil_map)

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

输出结果:

1
20x00xc04204de38

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

map中元素的返回值

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

1
2value := 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。

看下例子:

1
2
3
4
5
6
7
8
9
10
11
12
13my_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)

上面将输出如下结果:

1
2
3138 true0 false

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

len()和delete()

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14func 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中的该元素,将其赋值给两个变量,第二个变量就是元素是否存在的修饰变量。

1
2
3
4
5
6
7
8
9
10
11my_map := map[string]int{                "Java":11,                "Perl":8,                "Python":13,
            }

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

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

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

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

1
2
3
4
5
6
7
8
9
10my_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,则判断是否为空:

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

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

1
2
3
4
5
6my_map := map[string]int{                "Java":11,                "Perl":8,                "Python":13,                "Shell":0,
            }

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

迭代遍历map

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

1
2
3
4
5
6
7
8
9
10my_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:

1
2
3
4
5
6
7
8
9
10my_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中保存起来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23package mainimport "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。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18package mainfunc 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映射的值,则可以用于实现一种分支结构。

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

例如:

1
2
3
4
5
6
7
8
9
10func 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)
}
1
2
3
4
5
6
7
8
9func 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]())
}

 

转载请注明出处:https://www.cnblogs.com/f-ck-need-u/p/9857668.html


打开App,阅读手记
0人推荐
发表评论
随时随地看视频慕课网APP