golang基础语法(六)Map

目录

一、什么是Map

二、创建Map

1、方式1

2、方式2

三、遍历map

四、删除

五、线程安全的map

六、nil

[1、nil 标识符无法比较](#1、nil 标识符无法比较)

[2、nil 不是关键字或保留字](#2、nil 不是关键字或保留字)

[3、nil 没有默认类型](#3、nil 没有默认类型)

[4、不同类型 nil 的指针是一样的](#4、不同类型 nil 的指针是一样的)

[5、nil 是 map、slice、pointer、channel、func、interface 的零值](#5、nil 是 map、slice、pointer、channel、func、interface 的零值)

[6、不同类型的 nil 值占用的内存大小可能是不一样的](#6、不同类型的 nil 值占用的内存大小可能是不一样的)

七、new和make


一、什么是Map

map 是一种无序的键值对的集合。

map 是一种集合,所以我们可以像迭代数组和切片那样迭代它。不过map是无序的,我们无法决定它的返回顺序,这是因为 map 是使用hash表来实现的。

二、创建Map

1、方式1

map 是引用类型,可以使用如下方式声明:

复制代码
//[keytype] 和 valuetype 之间允许有空格。
var mapname map[keytype]valuetype

其中:

  • mapname 为 map 的变量名。
  • keytype 为键类型。
  • valuetype 是键对应的值类型。

在声明的时候不需要知道 map 的长度,因为 map 是可以动态增长的,未初始化的 map 的值是 nil,使用函数 len() 可以获取 map 中 键值对的数目。

复制代码
package main
import "fmt"
func main() {
    var mapLit map[string]int
    var mapAssigned map[string]int
    mapLit = map[string]int{"one": 1, "two": 2}
    mapAssigned = mapLit
    //mapAssigned 是 mapList 的引用,对 mapAssigned 的修改也会影响到 mapList 的值。
    mapAssigned["two"] = 3
    fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])
    fmt.Printf("Map assigned at \"two\" is: %d\n", mapLit["two"])
    fmt.Printf("Map literal at \"ten\" is: %d\n", mapLit["ten"])
}

2、方式2

复制代码
make(map[keytype]valuetype)

不要使用new创建map,否则会得到一个空引用的指针

map 可以根据新增的 key-value 动态的伸缩,因此它不存在固定长度或者最大限制,但是也可以选择标明 map 的初始容量 capacity,格式如下:

复制代码
make(map[keytype]valuetype, cap)

例如:

复制代码
map2 := make(map[string]int, 100)

当 map 增长到容量上限的时候,如果再增加新的 key-value,map 的大小会自动加 1,所以出于性能的考虑,对于大的 map 或者会快速扩张的 map,即使只是大概知道容量,也最好先标明。

既然一个 key 只能对应一个 value,而 value 又是一个原始类型,那么如果一个 key 要对应多个值怎么办?答案是:使用切片

例如,当我们要处理 unix 机器上的所有进程,以父进程(pid 为整形)作为 key,所有的子进程(以所有子进程的 pid 组成的切片)作为 value。

通过将 value 定义为 []int 类型或者其他类型的切片,就可以优雅的解决这个问题,示例代码如下所示:

复制代码
	// mp1 示例
	mp1 := make(map[int][]int)
	mp1[1] = []int{1, 2, 3}
	//slice := mp1[1]                    // 获取的是切片的副本
	slice1 := make([]int, len(mp1[1])) // 创建一个完全独立的副本(深拷贝)
	//slice[0] = 98                      // 修改副本
	slice1[0] = 98      // 修改副本
	fmt.Println(mp1[1]) // 输出 [1 2 3](深拷贝原始切片未改变)

	// mp2 示例
	mp2 := make(map[int]*[]int)
	mp2[1] = &[]int{1, 2, 3}
	slicePtr := mp2[1]   // 获取的是指向切片的指针
	(*slicePtr)[0] = 99  // 通过指针修改原始切片
	fmt.Println(*mp2[1]) // 输出 [99 2 3](原始切片已改变)

三、遍历map

map 的遍历过程使用 for range 循环完成,代码如下:

复制代码
scene := make(map[string]int)
scene["cat"] = 66
scene["dog"] = 4
scene["pig"] = 960
for k, v := range scene {
    fmt.Println(k, v)
}

注意:map是无序的,不要期望 map 在遍历时返回某种期望顺序的结果

四、删除

使用 delete() 内建函数从 map 中删除一组键值对,delete() 函数的格式如下:

复制代码
delete(map, 键)

map 为要删除的 map 实例,键为要删除的 map 中键值对的键。

复制代码
scene := make(map[string]int)
// 准备map数据
scene["cat"] = 66
scene["dog"] = 4
scene["pig"] = 960
delete(scene, "dog")
for k, v := range scene {
    fmt.Println(k, v)
}

Go语言中并没有为 map 提供任何清空所有元素的函数、方法,清空map的唯一办法就是重新 make一个新的map,不用担心垃圾回收的效率,Go语言中的并行垃圾回收效率比写一个清空函数要高效的多。注意map 在并发情况下,只读是线程安全的,同时读写是线程不安全的。

五、线程安全的map

并发情况下读写 map 时会出现问题,代码如下:

复制代码
// 创建一个int到int的映射
m := make(map[int]int)

// 开启一段并发代码
go func() {
    // 不停地对map进行写入
    for {
        m[1] = 1
    }
}()

// 开启一段并发代码
go func() {
    // 不停地对map进行读取
    for {
        _ = m[1]
    }
}()

// 无限循环, 让并发程序在后台执行
for {
}

运行代码会报错,输出如下:

复制代码
fatal error: concurrent map read and map write

错误信息显示,并发的 map 读和 map 写,也就是说使用了两个并发函数不断地对 map 进行读和写而发生了竞态问题,map 内部会对这种并发操作进行检查并提前发现。

需要并发读写时,一般的做法是加锁,但这样性能并不高,Go语言在 1.9 版本中提供了一种效率较高的并发安全的 sync.Map,sync.Map 和 map 不同,不是以语言原生形态提供,而是在 sync 包下的特殊结构。

sync.Map 有以下特性:

  • 无须初始化,直接声明即可。

  • sync.Map 不能使用 map 的方式进行取值和设置等操作,而是使用 sync.Map 的方法进行调用,Store 表示存储,Load 表示获取,Delete 表示删除。

  • 使用 Range 配合一个回调函数进行遍历操作,通过回调函数返回内部遍历出来的值,Range 参数中回调函数的返回值在需要继续迭代遍历时,返回 true,终止迭代遍历时,返回 false。

    package main
    import (
    "fmt"
    "sync"
    )
    func main() {
    //sync.Map 不能使用 make 创建
    var scene sync.Map
    // 将键值对保存到sync.Map
    //sync.Map 将键和值以 interface{} 类型进行保存。
    scene.Store("greece", 97)
    scene.Store("london", 100)
    scene.Store("egypt", 200)
    // 从sync.Map中根据键取值
    fmt.Println(scene.Load("london"))
    // 根据键删除对应的键值对
    scene.Delete("london")
    // 遍历所有sync.Map中的键值对
    //遍历需要提供一个匿名函数,参数为 k、v,类型为 interface{},每次 Range() 在遍历一个元素时,都会调用这个匿名函数把结果返回。
    scene.Range(func(k, v interface{}) bool {
    fmt.Println("iterate:", k, v)
    return true
    })
    }

解释一下:

|-------------------------------|---------------------|
| scene.Range(fn) | 遍历 sync.Map的所有键值对 |
| func(k, v interface{}) bool | 对每个键值对执行的操作 |
| return true | 继续遍历 |
| return false | 停止遍历 |

interface{}类似object接受任何类型

sync.Map 为了保证并发安全有一些性能损失,因此在非并发情况下,使用 map 相比使用 sync.Map 会有更好的性能

六、nil

在Go语言中

  • 布尔类型的零值(初始值)为 false
  • 数值类型的零值为 0
  • 字符串类型的零值为空字符串""
  • 而指针、切片、映射、通道、函数和接口的零值则是 nil

nil和其他语言的null是不同的

1、nil 标识符无法比较

复制代码
package main
import (
    "fmt"
)
func main() {
    //invalid operation: nil == nil (operator == not defined on nil)
    fmt.Println(nil==nil)
}

2、nil 不是关键字或保留字

nil 并不是Go语言的关键字或者保留字,也就是说我们可以定义一个名称为 nil 的变量,比如下面这样:

复制代码
//但不提倡这样做
var nil = errors.New("my god")

3、nil 没有默认类型

复制代码
package main
import (
    "fmt"
)
func main() {
    //error :use of untyped nil
    fmt.Printf("%T", nil)
    print(nil)
}

4、不同类型 nil 的指针是一样的

复制代码
package main

import (
	"fmt"
)

func main() {
	var arr []int
	var num *int
	fmt.Printf("%p\n", arr) //0x0
	fmt.Printf("%p", num) //0x0
}

5、nil 是 map、slice、pointer、channel、func、interface 的零值

映射、切片、指针、通道、函数和接口

复制代码
package main
import (
    "fmt"
)
func main() {
    var m map[int]string
    var ptr *int
    var c chan int
    var sl []int
    var f func()
    var i interface{}
    fmt.Printf("%#v\n", m)
    fmt.Printf("%#v\n", ptr)
    fmt.Printf("%#v\n", c)
    fmt.Printf("%#v\n", sl)
    fmt.Printf("%#v\n", f)
    fmt.Printf("%#v\n", i)
}

%#v是 Go 语言中一个强大的格式化动词,能显示变量的 ​​类型 + 值

零值是Go语言中变量在声明之后但是未初始化被赋予的该类型的一个默认值。

6、不同类型的 nil 值占用的内存大小可能是不一样的

复制代码
package main
import (
    "fmt"
    "unsafe"
)
func main() {
    var p *struct{}
    fmt.Println( unsafe.Sizeof( p ) ) // 8
    var s []int
    fmt.Println( unsafe.Sizeof( s ) ) // 24
    var m map[int]bool
    fmt.Println( unsafe.Sizeof( m ) ) // 8
    var c chan string
    fmt.Println( unsafe.Sizeof( c ) ) // 8
    var f func()
    fmt.Println( unsafe.Sizeof( f ) ) // 8
    var i interface{}
    fmt.Println( unsafe.Sizeof( i ) ) // 16
}

具体的大小取决于编译器和架构

七、new和make

make 关键字的主要作用是创建 slice、map 和 Channel 等内置的数据结构,而 new 的主要作用是为类型申请一片内存空间,并返回指向这片内存的指针。

  1. make 分配空间后,会进行初始化,new分配的空间被清零

  2. new 分配返回的是指针,即类型 *Type。make 返回引用,即 Type;

  3. new 可以分配任意类型的数据;

相关推荐
学习同学2 小时前
从0到1制作一个go语言游戏服务器(二)web服务搭建
服务器·前端·golang
-睡到自然醒~2 小时前
Golang 中的字符串:常见错误和最佳实践
开发语言·后端·golang
予非池物2 小时前
ubuntu安装go
开发语言·后端·golang
文心快码BaiduComate3 小时前
用Zulu轻松搭建国庆旅行4行诗网站
前端·javascript·后端
视睿3 小时前
【C++练习】06.输出100以内的所有素数
开发语言·c++·算法·机器人·无人机
草莓熊Lotso3 小时前
从 “Hello AI” 到企业级应用:Spring AI 如何重塑 Java 生态的 AI 开发
java·人工智能·经验分享·后端·spring
Terio_my3 小时前
Spring Boot 整合 Elasticsearch
spring boot·后端·elasticsearch
jjjxxxhhh1234 小时前
【QT】-QT为啥喜欢用类而不是结构体
开发语言·qt