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