golang之map入门 - Golang教程网

0.如何确定key是否存在? 如果访问了不存在的key会如何？

确定key是否存在,用ok判别式

if _,ok := m[key]; ok {
    print("key存在")
} else {
    print("key不存在")
}

参考:

在Go中操作map, 无论key是否存在,都不会panic或者返回error!

即可以访问不存在的key, 得到的值是对应 value 类型的零值

如下:

package main

import "fmt"

func main() {

	m := make(map[int]int)

	m[0] = 111

	m[1] = 1313

	m[2] = 9876

    fmt.Println(m[4])
    
	m2 := make(map[string]string)

	fmt.Println(m2["cuishuang"])

	var m3 map[string]string

	fmt.Println(m3["dashen"])

}

输出为:

1.key的类型可以是哪些

简言之,可以判断(==)的类型,都可以作为map的键名.

如 bool, int，float，string, 指针, channel 以及只包含前面几个类型的 interface,struct, array

而如 slice， map 以及 function 不能作为map的key，因为这几种类型无法用 == 来判断

原文如下:

As mentioned earlier(如前所述), map keys may be of any type that is comparable. The language spec defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types. Notably absent from the list are slices, maps, and functions; these types cannot be compared using ==, and may not be used as map keys.

comparable types, 即可比较类型,可判等类型

直接 map1 == map2 是错误的invalid operation: d1 == d2 (struct containing map[string]int cannot be compared)如果接口存储的动态类型值是不可比较的，则运行时会报错切片唯一合法的比较操作是和nil比较

2.map键值互换

o := map[string]int{"a": 0, "b": 0, "c": 2}

如果原map的值不唯一（如上），会导致新map无法完全包含原map的键值对(相同key会被覆盖)。该问题可以采用多值map来解决,即将新map的键值定义为一个切片类型


var (
    o = map[string]int{"a": 0, "b": 0, "c": 2}
)

func main() {

    fmt.Println(o)

    n := map[int][]string{}
    for k, v := range o {
        n[v] = append(n[v], k)
    }
    fmt.Println(n)
}

输出:

1
2

map[a:0 b:0 c:2]
map[0:[a b] 2:[c]]

3.可以对map的键值取指针吗?

不可以!

map 中的元素并不是一个变量，而是一个值。 因而不能对 map 的元素进行取址操作(类似于&5，编译不过)

package main

import (
	"fmt"
)

func main() {
	
	m := make(map[string]int)
	
	m["age"] = 27
	
	fmt.Println(&m["age"])
}

报错:

cannot take the address of m["age"]

4.当 map 的键值为结构体类型的值，那么无法直接修改结构体中的字段值

go 中的 map 的 value 本身是不可寻址的，因为 map 的扩容的时候，可能要做 key/val pair迁移

package main

import "fmt"

func main() {
	type person struct {
		name string
		city string
		age  int
	}
	var personMap = make(map[int]person)

	p5 := person{
		name: "史铁生",
		city: "北京",
		age:  20,
	}

	p1 := person{
		"莫言",
		"山东高密",
		30,
	}

	personMap[p5.age] = p5
	personMap[p1.age] = p1

	fmt.Println("map为:", personMap)

	// 修改
	// 常见错误  不能直接修改map 结构体中的值
	//personMap[p1.age].name = "蒲松龄"  // cannot assign to struct field personMap[p1.age].name in map

	// --------正确方式---------

	fmt.Println("-----以下为正确修改方式-----")
	var personMap2 = make(map[int]*person)

	personMap2[p5.age] = &p5
	personMap2[p1.age] = &p1

	fmt.Println(*personMap2[p1.age])
	fmt.Println(*personMap2[p5.age])

	fmt.Println("修改后：")

	personMap2[p1.age].name = "蒲松龄"

	fmt.Println(*personMap2[20])
	fmt.Println(*personMap2[p1.age])

}

输出：

map为: map[20:{史铁生 北京 20} 30:{莫言 山东高密 30}]
-----以下为正确修改方式-----
{莫言 山东高密 30}
{史铁生 北京 20}
修改后：
{史铁生 北京 20}
{蒲松龄 山东高密 30}

5.map之间能否直接判等?

不能！

直接 map1 == map2 是错误的

==

reflect.DeepEqual

参考:

6.实现key有序的map

借助slice就可以

package main

import (
	"fmt"
	"sort"
)

func main() {

	var m = make(map[int]string)

	m[1] = "张三"
	m[2] = "李四"
	m[3] = "王五"
	m[4] = "陈六子"

	fmt.Println()
	fmt.Println("下面迭代时会乱序：")
	fmt.Println()

	/*
		第3位是王五
		第4位是陈六子
		第1位是张三
		第2位是李四
		（且每次执行输出顺序不确定，可能每次都不一样）
	*/

	for k, v := range m {
		fmt.Printf("第%d位是%s\n", k, v)
	}

	// 改为顺序输出：
	fmt.Println("---------------顺序输出----------------")
	sli := make([]int, 0)
	for k := range m {
		sli = append(sli, k)
	}

	//sort.Strings(sli)
	sort.Ints(sli)

	for _, val := range sli {
		fmt.Printf("第%d位是%s\n", val, m[val])
	}

	/*
		---------------顺序输出----------------
		第1位是张三
		第2位是李四
		第3位是王五
		第4位是陈六子
	*/
}

7.map 的并发读写问题

并发对map读写可能会报fatal error

并发读写slice不会报错(最后的数据可能不对)

更多参考:

8.各项操作的时间复杂度

以下是 Go 中常见的各种 map 操作的时间复杂度：

查找元素（Get）：平均时间复杂度为 O(1)，最坏情况下为 O(n)。
插入元素（Put）：平均时间复杂度为 O(1)，最坏情况下为 O(n)。
删除元素（Delete）：平均时间复杂度为 O(1)，最坏情况下为 O(n)。
遍历元素（Iteration）：时间复杂度为 O(n)，其中 n 为 map 的大小。

需要注意的是，由于 map 的实现方式和哈希表类似，因此查找、插入、删除等操作的时间复杂度是平均意义下的复杂度，具体的时间复杂度会受到 hash 算法、哈希冲突等因素的影响，最坏情况下可能会退化到 O(n)。