Go语言基础之map
Go语言基础之map
Go语言中提供的映射关系容器为map，其内部使用散列表（hash）实现。
map
map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用,map是无序的。
一、map定义
Go语言中 map的定义语法如下：
map[KeyType]ValueType
其中，
- KeyType:表示键的类型。
- ValueType:表示键对应的值的类型。
map类型的变量默认初始值为nil，需要使用make()函数来分配内存。语法为：
make(map[KeyType]ValueType, [cap])
var a map[int]string = make(map[int]string)
var b = make(map[int]string)
c := make(map[int]string)
其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量，使用必须通过make分配内存初始化。
二、map基本使用
map中的数据都是成对出现的，map的基本使用示例代码如下：
func main() {
scoreMap := make(map[string]int, 8)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
fmt.Println(scoreMap)
fmt.Println(scoreMap["小明"])
fmt.Printf("type of a:%T\n", scoreMap)
}
输出：
map[小明:100 张三:90]
100
type of a:map[string]int
map也支持在声明的时候填充元素，例如：
func main() {
userInfo := map[string]string{
"username": "bb",
"password": "123456",
}
fmt.Println(userInfo) //
}
添加元素
// 给map添加元素
var a map[int]string = map[int]string{1: "randy", 2: "barry"}
//不存在的key（就是放进去）
a[9] = "xxx"
//存在的kye(替换)
a[2] = "yyy"
fmt.Println(a)
当做参数传递
var a map[int]string = map[int]string{1:"randy", 2:"barry"}
a := map[int]string{1:"randy", 2:"barry"}
fmt.Println("函数执行前", a)
test(a) // 传参会改变自身值
fmt.Println("函数执行完", a)
func test(a map[int]string) {
a[1] = "老王"
fmt.Println("函数内",a)
}
函数执行前 map[1:randy 2:barry]
函数内 map[1:老王 2:barry]
函数执行完 map[1:老王 2:barry]
相等性，不能直接比较
var a=map[int]string{1:"lqz"}
//var b=map[int]string{1:"lqz"}
//if a==b{
// //报错,不能比较
//}
if a==nil{
fmt.Println("空的")
}else {
fmt.Println("不是空的")
}
三、判断某个键是否存在
Go语言中有个判断map中键是否存在的特殊写法，格式如下:
value, ok := map[key]
举个例子：
func main() {
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
// 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值
v, ok := scoreMap["张三"]
if ok {
fmt.Println(v)
} else {
fmt.Println("查无此人")
}
}
四、map的遍历
Go语言中使用for range遍历map。
func main() {
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["娜扎"] = 60
for k, v := range scoreMap {
fmt.Println(k, v)
}
}
但我们只想遍历key的时候，可以按下面的写法：
func main() {
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["娜扎"] = 60
for k := range scoreMap {
fmt.Println(k)
}
}
注意： 遍历map时的元素顺序与添加键值对的顺序无关。
五、使用delete()函数删除键值对
使用delete()内建函数从map中删除一组键值对，delete()函数的格式如下：
delete(map, key)
其中，
- map:表示要删除键值对的map
- key:表示要删除的键值对的键
示例代码如下：
func main(){
scoreMap := make(map[string]int)
scoreMap["张三"] = 90
scoreMap["小明"] = 100
scoreMap["娜扎"] = 60
delete(scoreMap, "小明")//将小明:100从map中删除
for k,v := range scoreMap{
fmt.Println(k, v)
}
}
六、按照指定顺序遍历map
func main() {
rand.Seed(time.Now().UnixNano()) //初始化随机数种子
var scoreMap = make(map[string]int, 200)
for i := 0; i <; 100; i++ {
key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
value := rand.Intn(100) //生成0~99的随机整数
scoreMap[key] = value
}
//取出map中的所有key存入切片keys
var keys = make([]string, 0, 200)
for key := range scoreMap {
keys = append(keys, key)
}
//对切片进行排序
sort.Strings(keys)
//按照排序后的key遍历map
for _, key := range keys {
fmt.Println(key, scoreMap[key])
}
}
七、元素为map类型的切片
下面的代码演示了切片中的元素为map类型时的操作：
func main() {
var mapSlice = make([]map[string]string, 3)
for index, value := range mapSlice {
fmt.Printf("index:%d value:%v\n", index, value)
}
fmt.Println("after init")
// 对切片中的map元素进行初始化
mapSlice[0] = make(map[string]string, 10)
mapSlice[0]["name"] = "小王子"
mapSlice[0]["password"] = "123456"
mapSlice[0]["address"] = "沙河"
for index, value := range mapSlice {
fmt.Printf("index:%d value:%v\n", index, value)
}
}
index:0 value:map[]
index:1 value:map[]
index:2 value:map[]
after init
index:0 value:map[address:沙河 name:小王子 password:123456]
index:1 value:map[]
index:2 value:map[
7.1 实现map有序
var a map[int]map[int]string=make(map[int]map[int]string)
fmt.Println(a)
a[1]=make(map[int]string) // 值为map类型要初始化才可以赋值
a[2]=make(map[int]string)
a[1][1]="randy"
fmt.Println(a[1][1])
fmt.Println(a)
var a =make(map[int]string)
var b =make([]int,4)
a[1]="lqz"
b=append(b,1)
a[5]="randy"
b=append(b,5)
a[2]="xxx"
b=append(b,2)
for _,v:=range b{
fmt.Println(a[v])
}
for _,v:=range a{
fmt.Println(v)
}
八、值为切片类型的map
下面的代码演示了map中值为切片类型的操作：
func main() {
var sliceMap = make(map[string][]string, 3)
fmt.Println(sliceMap)
fmt.Println(“after init“)
key := "中国"
value, ok := sliceMap[key]
if !ok {
value = make([]string, 0, 2)
}
value = append(value, “北京“, “上海“)
sliceMap[key] = value
fmt.Println(sliceMap)
}
九、go禁止对map元素取地址
当新增元素时，map也会随着元素数量的增长而重新分配更大的内存空间，从而可能导致之前的地址无效，了解即可。但是有一点需要注意的是go语言设计规定我们可以对切片中的元素取地址，但是我们无法对map中的元素取地址
// 示范1
numSlice:=[]int{111,222,333}
fmt.Println(&numSlice[0]) // 0xc00001e0c0
// 示范2
var m = make(map[string]int)
m["k1"]=111
fmt.Println(&m["k1"]) // 异常cannot take the address of m["k1"]
解释1：常数为何不可以被寻址/取地址
如果常数被取地址的话，那么意味着我们可以通过指针修改常数的值，这就违背了常数的定义，所以go语言的底层设计禁止我们对常数寻址
解释2：map中的元素为何不可以被取地址
原因1：当我们根据key去取map类型中的元素值时，如果key不存在，则返回零值，而零值是不可变对象，所以go语言的底层设计禁止我们对其进行取地址操作
原因2: Go中map实现中元素的地址是变化的，这意味着寻址的结果是无意义的，所以go语言的底层设计禁止我们对其进行取地址操作
解释3：为何slice切片不管是否可以寻址，但它的元素是可以被取地址的
我们上面提到禁止对map元素取址的原因是map可能随着元素数量的增长而重新分配更大的内存空间，从而可能导致之前取得的元素地址无效。
而slice的底层是一个数组，所以我们对切片中的元素取地址就是在对底层数组中的元素取地址，只要底层数组不变，那么我基于当前切片，取其中元素的地址永远是固定的。虽然对于切片类型来说，随着元素数量增多同样也是会扩容，但是每次append操作扩容之后返回的都是一个新切片的地址，该切片指向新的底层数组，我们基于当前·新切片，取其中元素的地址仍然是固定的，因为永远是在取当前新切片对应底层新数组中元素的地址
x:=[3]int{111,222,333} // 数组
y:=x[:] // 切片
fmt.Println(&x[0]) // 0xc0000180e0
fmt.Println(&y[0]) // 0xc0000180e0
关键区别就体现在：对于map来说，随着元素的增多，当前map中的元素地址就会发生变化，而我们用的仍然是指向当前地址的map
解释4：为何字符中的字符/字节又不可以被取地址呢？
因为字符串是不可变的
十、总结
- map是一种无序的基于
key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用 - 定义:
var mapname map[KeyType]ValueType,var map1 map[int]string添加值要通过make分配内存,没有分配内存默认为nil，添加元素到 nil map 中，会触发运行时 panic，因此 map 必须使用make函数初始化 - 定义并分配内存:
var a map[key类型]value类型=make( map[key类型]value类型, cap)key必须可哈希数字或字符串 - 声明并初始化
var a map[key类型]value类型=map[key类型]value类型{key类型1:value类型1,key类型2:value类型3} - 增加和修改值:
mapname[key]=value,key存在覆盖原有值,key不存在添加值 - 删除:
delete(map, key) - 查:
mapNmae[key],不存在的key值为零值不会报错 - 遍历跟数组完全一样 range 数组/切片/map,遍历map获取的key-value是无序的
- 取值判断key是否存在
ok,v:=a[key],ok是true或false，v是真正的值 - 当参数传递，会修改原map
- 获取map长度 len
- 相等性不能直接比较，只能直接跟nil比较,==
只能用来检查 map 是否为nil - map是无序的,要想获取有序通过切片或数组记录创建时候的key
