【go进阶】map

最新推荐文章于 2024-03-21 17:36:11 发布

Herbert_JL

最新推荐文章于 2024-03-21 17:36:11 发布

阅读量163

点赞数

分类专栏： # golang 文章标签： golang go java

本文链接：https://blog.csdn.net/weixin_45603902/article/details/130683473

版权

golang 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1 map 的基本介绍（为什么引入map）
2 map 的声明
- map 声明基本语法
- map 声明的举例
3 map 的使用
- map 在使用前一定要 make
- map 的使用
4 map 遍历：for-range 的结构遍历
5 map 的增删改查操作
6 map 切片
7 map 排序
8 map 使用细节
9 map的内存存储方式；

1 map 的基本介绍（为什么引入map）

在Go语言中引入map的主要原因是为了提供一种高效的键值对存储和检索机制。map可以将键与值关联起来，以便在给定键的情况下能够快速地查找到对应的值。

数据存储和检索：map提供了一种方便的方式来存储和检索数据。通过使用键作为索引，可以快速访问和修改与之关联的值。
动态扩容：map可以根据需要自动扩容，无需手动管理容量。这使得在处理未知数量的键值对时非常方便，不需要提前确定容量大小。
高效的查找操作：map内部使用哈希表实现，这使得在map中进行键值对的查找操作具有常数时间复杂度，即O(1)。相比于遍历数组或切片进行查找，map提供了更高效的查找性能。
动态更新：map允许在运行时动态地添加、更新和删除键值对。这对于需要频繁修改数据的场景非常有用，无需事先知道键值对的数量。
灵活的键类型：map的键可以是任意可比较类型，例如整数、字符串、结构体等。这使得map适用于各种不同的应用场景。
内置语法支持：Go语言为map提供了简洁且易于使用的语法。通过map[key]的形式，可以直接访问和操作键值对。
总体而言，map在Go语言中提供了一种方便、高效的数据结构，适用于存储和检索键值对数据。它在许多实际应用中都扮演着重要的角色，如缓存、配置存储、数据索引等。

2 map 的声明

map 声明基本语法

定义一个map: var map 变量名 map[keytype]valuetype

key 可以是什么类型?
golang 中的 map，的 key 可以是很多种类型，比如 bool, 数字，string, 指针, channel , 还可以是只包含前面几个类型的接口, 结构体, 数组
通常 key 为 int 、string
注意: slice， map 还有 function 不可以，因为这几个没法用 == 来判断

valuetype 可以是什么类型?
valuetype 的类型和 key 基本一样，这里我就不再赘述了通常为: 数字(整数,浮点数),string,map,struct

map 声明的举例

map 声明的举例：
var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string
注意：声明是不会分配内存的，初始化需要 make ，分配内存后才能赋值和使用。

3 map 的使用

map 在使用前一定要 make

map 的 key 是不能重复，如果重复了，则以最后这个 key-value 为准

map 的 value 是可以相同的.
map 的 key-value 是无序
make 内置函数数目

map 的使用

第1种使用方式

	var a map[string]string
	//在使用map前，需要先make , make的作用就是给map分配数据空间
	a = make(map[string]string, 10)
	a["no1"] = "宋江" //ok?
	a["no2"] = "吴用" //ok?
	a["no1"] = "武松" //ok?
	a["no3"] = "吴用" //ok?
	fmt.Println(a)

第2种使用方式

cities := make(map[string]string)
	cities["no1"] = "北京"
	cities["no2"] = "天津"
	cities["no3"] = "上海"
	fmt.Println(cities)

第3种使用方式

heroes := map[string]string{
		"hero1" : "宋江",
		"hero2" : "卢俊义",
		"hero3" : "吴用",
	}
	heroes["hero4"] = "林冲"
	fmt.Println("heroes=", heroes)

4 map 遍历：for-range 的结构遍历

案例演示相对复杂的 map 遍历：该 map 的 value 又是一个 map

package main
import (
	"fmt"
)

func main() {
	//使用for-range遍历map
	//第二种方式
	cities := make(map[string]string)
	cities["no1"] = "北京"
	cities["no2"] = "天津"
	cities["no3"] = "上海"
	
	for k, v := range cities {
		fmt.Printf("k=%v v=%v\n", k, v)
	}
	//k=no1 v=北京
	//k=no2 v=天津                      
	//k=no3 v=上海

	fmt.Println("cities 有", len(cities), " 对 key-value")
	//cities 有 3  对 key-value  

	//使用for-range遍历一个结构比较复杂的map
	studentMap := make(map[string]map[string]string)
	
	studentMap["stu01"] =  make(map[string]string, 3)
	studentMap["stu01"]["name"] = "tom"
	studentMap["stu01"]["sex"] = "男"
	studentMap["stu01"]["address"] = "北京长安街~"

	studentMap["stu02"] =  make(map[string]string, 3) //这句话不能少!!
	studentMap["stu02"]["name"] = "mary"
	studentMap["stu02"]["sex"] = "女"
	studentMap["stu02"]["address"] = "上海黄浦江~"

	//一个key对应一个range
	for k1, v1 := range studentMap {
		fmt.Println("k1=", k1)
		for k2, v2 := range v1 {
				fmt.Printf("\t k2=%v v2=%v\n", k2, v2)
		}
		fmt.Println()
	}
}

k1= stu01                         
         k2=sex v2=男             
         k2=address v2=北京长安街~
         k2=name v2=tom           
                                  
k1= stu02                         
         k2=name v2=mary          
         k2=sex v2=女             
         k2=address v2=上海黄浦江~

5 map 的增删改查操作

map 增加和更新：

map[“key”] = value //如果 key 还没有，就是增加，如果 key 存在就是修改。
map 是引用类型，遵守引用类型传递的机制，在一个函数接收 map，修改后，会直接修改原来的 map

	cities := make(map[string]string)
	cities["no1"] = "北京"
	cities["no2"] = "天津"
	cities["no3"] = "上海"
	fmt.Println(cities)

	//因为 no3这个key已经存在，因此下面的这句话就是修改
	cities["no3"] = "上海~" 
	fmt.Println(cities)

map 扩容

map 的容量达到后，再想 map 增加元素，会自动扩容，并不会发生 panic，也就是说 map 能动态的增长键值对(key-value)

package main

import "fmt"

func main() {
	m := make(map[string]int, 2)
	m["apple"] = 1
	m["banana"] = 2

	fmt.Println("Map:", m)
	fmt.Println("Length:", len(m))

	// 尝试添加一个新的键值对
	m["orange"] = 3

	fmt.Println("Map:", m)
	fmt.Println("Length:", len(m))
}

Map: map[apple:1 banana:2]
Length: 2                          
Map: map[apple:1 banana:2 orange:3]
Length: 3

map 删除： `delete(map，"key")`

delete 是一个内置函数，如果 key 存在，就删除该 key-value,如果 key 不存在，不操作，但是也不会报错

	//演示删除
	delete(cities, "no1")
	fmt.Println(cities)
	//当delete指定的key不存在时，删除不会操作，也不会报错
	delete(cities, "no4")
	fmt.Println(cities)

如果我们要删除 map 的所有 key ,没有一个专门的方法一次删除，可以遍历一下 key, 逐个删除或者 map = make(…)，make 一个新的，让原来的成为垃圾，被 gc 回收

    //如果希望一次性删除所有的key
	//1. 遍历所有的key,如何逐一删除 [遍历]
	//2. 直接make一个新的空间
	cities = make(map[string]string)
	fmt.Println(cities)

map 查找：

使用索引访问元素：可以使用键作为索引来访问map中的元素。例如：

m := make(map[string]int)
m["apple"] = 1
m["banana"] = 2

fmt.Println(m["apple"])    // 输出: 1
fmt.Println(m["banana"])   // 输出: 2

如果指定的键不存在于map中，则会返回该值类型的零值。

value, ok := key[“value”]

m := make(map[string]int)
m["apple"] = 1

value, ok := m["apple"]
fmt.Println(value, ok)    // 输出: 1 true

value, ok = m["banana"]
fmt.Println(value, ok)    // 输出: 0 false

在上面的示例中，变量value将接收键对应的值，而变量ok则表示键是否存在。如果存在，ok的值为true，否则为false。

	val, ok := cities["no1"]
	if ok {
		fmt.Printf("有no1 key 值为%v\n", val)
	} else {
		fmt.Printf("没有no1 key\n")
	}

说明：如果cities这个 map 中存在 “no1” ，那么 ok 就会返回 true,否则返回 false

使用range遍历map：可以使用range关键字遍历map的所有键值对。例如：

m := make(map[string]int)
m["apple"] = 1
m["banana"] = 2

for key, value := range m {
    fmt.Println(key, value)
}

apple 1
banana 2

6 map 切片

切片的数据类型如果是 map，则我们称为 slice of map，map 切片，这样使用则 map 个数就可以动态变化了。
案例：

package main

import (
	"fmt"
)

func main() {
	//演示map切片的使用
	/*
		要求：使用一个map来记录monster的信息 name 和 age, 也就是说一个
		monster对应一个map,并且妖怪的个数可以动态的增加=>map切片
	*/
	//1. 声明一个map切片
	var monsters []map[string]string
	monsters = make([]map[string]string, 2) //准备放入两个妖怪
	//2. 增加第一个妖怪的信息
	if monsters[0] == nil {
		monsters[0] = make(map[string]string, 2)
		monsters[0]["name"] = "牛魔王"
		monsters[0]["age"] = "500"
	}

	if monsters[1] == nil {
		monsters[1] = make(map[string]string, 2)
		monsters[1]["name"] = "玉兔精"
		monsters[1]["age"] = "400"
	}

	// 下面这个写法越界。切片不会自动扩容。
	//if monsters[2] == nil {
	//	monsters[2] = make(map[string]string, 2)
	//	monsters[2]["name"] = "狐狸精"
	//	monsters[2]["age"] = "300"
	//}

	//这里我们需要使用到切片的append函数，可以动态的增加monster
	//1. 先定义个monster信息
	newMonster := map[string]string{
		"name": "新的妖怪~火云邪神",
		"age":  "200",
	}
	monsters = append(monsters, newMonster)

	fmt.Println(monsters)
}

7 map 排序

golang 中没有一个专门的方法针对 map 的 key 进行排序
golang 中的 map 默认是无序的，注意也不是按照添加的顺序存放的，你每次遍历，得到的输出可能不一样.
golang 中 map 的排序，是先将 key 进行排序，然后根据 key 值遍历输出即可。

package main
import (
	"fmt"
	"sort"
)

func main() {

	//map的排序
	map1 := make(map[int]int, 10)
	map1[10] = 100
	map1[1] = 13
	map1[4] = 56
	map1[8] = 90

	fmt.Println(map1)

	//如果按照map的key的顺序进行排序输出
	//1. 先将map的key 放入到 切片中
	//2. 对切片排序 
	//3. 遍历切片，然后按照key来输出map的值

	var keys []int
	for k, _ := range map1 {
		keys = append(keys, k)
	}
	//排序
	sort.Ints(keys)
	fmt.Println(keys)

	for _, k := range keys{
		fmt.Printf("map1[%v]=%v \n", k, map1[k])
	}
}

8 map 使用细节

并发访问map时可能导致的竞态条件，可以通过使用互斥锁或使用Go的并发安全sync.Map来解决这个问题。
map 的 value 也经常使用 struct 类型，更适合管理复杂的数据(比前面 value 是一个 map 更好)，比如 value 为 Student 结构体

package main
import (
	"fmt"
)

//定义一个学生结构体
type Stu struct {
	Name string
	Age int
	Address string
}

func main() {
	//map的value 也经常使用struct 类型，
	//更适合管理复杂的数据(比前面value是一个map更好)，
	//比如value为 Student结构体 【案例演示，因为还没有学结构体，体验一下即可】
	//1.map 的 key 为 学生的学号，是唯一的
	//2.map 的 value为结构体，包含学生的 名字，年龄, 地址

	students := make(map[string]Stu, 10)
	//创建2个学生
	stu1 := Stu{"tom", 18, "北京"}
	stu2 := Stu{"mary", 28, "上海"}
	students["no1"] = stu1
	students["no2"] = stu2

	fmt.Println(students)
	// map[no1:{tom 18 北京} no2:{mary 28 上海}]


	//遍历各个学生信息
	for k, v := range students {
		fmt.Printf("学生的编号是%v \n", k)
		fmt.Printf("学生的名字是%v \n", v.Name)
		fmt.Printf("学生的年龄是%v \n", v.Age)
		fmt.Printf("学生的地址是%v \n", v.Address)
		fmt.Println()
	}
	
}

 map[no1:{tom 18 北京} no2:{mary 28 上海}]
 
学生的编号是no1                          
学生的名字是tom                          
学生的年龄是18                           
学生的地址是北京                         
                                         
学生的编号是no2                          
学生的名字是mary                         
学生的年龄是28                           
学生的地址是上海

9 map的内存存储方式；

在Go语言中，map在内存中的存储形式是一个指向runtime.hmap结构的指针。runtime.hmap是Go语言运行时系统实现的哈希表结构。
runtime.hmap的定义如下：

type hmap struct {
    count     int                        // 哈希表中的键值对数量
    flags     uint8                      // 哈希表的标志位
    B         uint8                      // 哈希表的桶数量的对数
    noverflow uint16                     // 溢出桶的数量
    hash0     uint32                     // 哈希种子
    buckets   unsafe.Pointer             // 指向桶数组的指针
    oldbuckets unsafe.Pointer             // 指向旧桶数组的指针，用于扩容时的数据迁移
    nevacuate uintptr                    // 扩容过程中已迁移的键值对数量
    extra     *mapextra                  // 用于存储额外信息的指针
}

runtime.hmap结构体包含了一些用于管理哈希表的字段，其中最重要的是buckets字段，它是一个指向桶数组的指针。桶数组存储了实际的键值对数据，每个桶可以容纳多个键值对。

每个桶的定义如下：

type bmap struct {
    tophash [bucketCnt]uint8
    // ...
    // 其他字段
    // ...
    kv      []keyvalue
}

bmap结构体中的tophash数组存储了键的哈希值的前八位，用于快速比较键的哈希值。kv字段是一个keyvalue结构体的切片，用于存储键值对数据。

keyvalue结构体的定义如下：

type keyvalue struct {
    key   interface{}
    value interface{}
}

每个key-value结构体表示一个键值对，其中key和value字段分别存储键和对应的值。

通过上述的结构体定义，可以看出map在内存中的存储形式是一种基于哈希表的数据结构，通过桶数组和键值对的方式来组织和存储数据。这种存储方式使得在map中进行键值对的查找操作具有高效的性能。