3.容器Map · golang

Golang Map：引用類型，哈希表。一堆鍵值對的未排序集合。鍵必須是支持相等運算符 ("=="、"!=") 類型，如 number、string、 pointer、array、struct，以及對應的 interface。值可以是任意類型，沒有限制。 map聲明聲明map的語法如下 ~~~ var map變量名 map[key] value 其中：key為鍵類型，value為值類型例如：value不僅可以是標注數據類型，也可以是自定義數據類型 ~~~ ~~~ package main type personInfo struct { ID string Name string Address string } var m1 map[string]int var m2 map[string]personInfo func main() {} ~~~ map初始化直接初始化（創建） ~~~ package main import ( "fmt" ) var m1 map[string]float32 = map[string]float32{"C": 5, "Go": 4.5, "Python": 4.5, "C++": 2} func main() { m2 := map[string]float32{"C": 5, "Go": 4.5, "Python": 4.5, "C++": 2} m3 := map[int]struct { name string age int }{ 1: {"user1", 10}, // 可省略元素類型。 2: {"user2", 20}, } fmt.Printf("全局變量 map m1 : %v\n", m1) fmt.Printf("局部變量 map m2 : %v\n", m2) fmt.Printf("局部變量 map m3 : %v\n", m3) } ~~~ 輸出結果： ~~~ 全局變量 map m1 : map[Python:4.5 C++:2 C:5 Go:4.5] 局部變量 map m2 : map[C++:2 C:5 Go:4.5 Python:4.5] 局部變量 map m3 : map[2:{user2 20} 1:{user1 10}] 注意：由m1,m2可以看出map是鍵值對的無序集合。 ~~~ 通過make初始化（創建） Go語言提供的內置函數make()可以用于靈活地創建map。預先給 make 函數一個合理元素數量參數，有助于提升性能。因為事先申請一大塊內存，可避免后續操作時頻繁擴張。 ~~~ package main import ( "fmt" ) func main() { // 創建了一個鍵類型為string,值類型為int的map m1 := make(map[string]int) // 也可以選擇是否在創建時指定該map的初始存儲能力，如創建了一個初始存儲能力為5的map m2 := make(map[string]int, 5) m1["a"] = 1 m2["b"] = 2 fmt.Printf("局部變量 map m1 : %v\n", m1) fmt.Printf("局部變量 map m2 : %v\n", m2) } ~~~ 輸出結果： ~~~ 局部變量 map m1 : map[a:1] 局部變量 map m2 : map[b:2] ~~~ map操作：插入、更新、查找、刪除、判斷是否存在、求長度 ~~~ package main import ( "fmt" ) func main() { m := map[string]string{"key0": "value0", "key1": "value1"} fmt.Printf("map m : %v\n", m) //map插入 m["key2"] = "value2" fmt.Printf("inserted map m : %v\n", m) //map修改 m["key0"] = "hello world!" fmt.Printf("updated map m : %v\n", m) //map查找 val, ok := m["key0"] if ok { fmt.Printf("map's key0 is %v\n", val) } // 長度：獲取鍵值對數量。 len := len(m) fmt.Printf("map's len is %v\n", len) // cap 無效，error // cap := cap(m) //invalid argument m (type map[string]string) for cap // fmt.Printf("map's cap is %v\n", cap) // 判斷 key 是否存在。 if val, ok = m["key"]; !ok { fmt.Println("map's key is not existence") } // 刪除，如果 key 不存在，不會出錯。 if val, ok = m["key1"]; ok { delete(m, "key1") fmt.Printf("deleted key1 map m : %v\n", m) } } ~~~ 輸出結果： ~~~ map m : map[key0:value0 key1:value1] inserted map m : map[key0:value0 key1:value1 key2:value2] updated map m : map[key0:hello world! key1:value1 key2:value2] map's key0 is hello world! map's len is 3 map's key is not existence deleted key1 map m : map[key0:hello world! key2:value2] ~~~ map遍歷：不能保證迭代返回次序，通常是隨機結果，具體和版本實現有關。 ~~~ package main import ( "fmt" ) func main() { m := make(map[int]int) for i := 0; i < 10; i++ { m[i] = i } fmt.Println(m) fmt.Println(m) for j := 0; j < 2; j++ { fmt.Println("---------------------") for k, v := range m { fmt.Printf("key -> value : %v -> %v\n", k, v) } } } ~~~ 輸出結果： ~~~ map[6:6 8:8 2:2 1:1 3:3 4:4 5:5 7:7 9:9 0:0] map[2:2 6:6 8:8 5:5 7:7 9:9 0:0 1:1 3:3 4:4] --------------------- key -> value : 2 -> 2 key -> value : 6 -> 6 key -> value : 8 -> 8 key -> value : 9 -> 9 key -> value : 0 -> 0 key -> value : 1 -> 1 key -> value : 3 -> 3 key -> value : 4 -> 4 key -> value : 5 -> 5 key -> value : 7 -> 7 --------------------- key -> value : 8 -> 8 key -> value : 2 -> 2 key -> value : 6 -> 6 key -> value : 3 -> 3 key -> value : 4 -> 4 key -> value : 5 -> 5 key -> value : 7 -> 7 key -> value : 9 -> 9 key -> value : 0 -> 0 key -> value : 1 -> 1 ~~~ slice與map操作（slice of map） ~~~ package main import ( "fmt" ) func main() { items := make([]map[int]int, 5) for i := 0; i < 5; i++ { items[i] = make(map[int]int) } items[0][0] = 0 items[1][2] = 3 fmt.Println(items) } ~~~ 輸出結果： ~~~ [map[0:0] map[2:3] map[] map[] map[]] ~~~ map排序：先獲取所有key，把key進行排序，再按照排序好的key，進行遍歷。 ~~~ package main import ( "fmt" "sort" ) func main() { m := map[string]string{"q": "q", "w": "w", "e": "e", "r": "r", "t": "t", "y": "y"} var slice []string for k, _ := range m { slice = append(slice, k) } fmt.Printf("clise string is : %v\n", slice) sort.Strings(slice[:]) fmt.Printf("sorted slice string is : %v\n", slice) for _, v := range slice { fmt.Println(m[v]) } } ~~~ 輸出結果： ~~~ clise string is : [e r t y q w] sorted slice string is : [e q r t w y] e q r t w y ~~~ map反轉：初始化另外一個map，把key、value互換即可. ~~~ package main import ( "fmt" ) func main() { m := map[int]string{1: "x", 2: "w", 3: "e", 4: "r", 5: "t", 6: "y"} fmt.Println(m) m_rev := make(map[string]int) for k, v := range m { m_rev[v] = k } fmt.Println(m_rev) } ~~~ 輸出結果： ~~~ map[3:e 4:r 5:t 6:y 1:x 2:w] map[r:4 t:5 y:6 x:1 w:2 e:3] ~~~ 從 map 中取回的是一個 value 臨時復制品，對其成員的修改是沒有任何意義的。 ~~~ package main import ( "fmt" ) func main() { m := map[int]string{1: "x", 2: "w"} fmt.Println(m) for k, v := range m { m[k] = v + v //修改map的值 v = v + "copy" //臨時復制品，修改無效 } fmt.Println(m) } ~~~ 輸出結果： ~~~ ~~~ 容器和結構體（map and struct） ~~~ 語法比較： map[type]struct map[type]*struct ~~~ ~~~ package main import "fmt" func main() { type user struct{ name string } /* 當 map 因擴張而重新哈希時，各鍵值項存儲位置都會發生改變。因此，map 被設計成 not addressable。類似 m[1].name 這種期望透過原 value 指針修改成員的行為自然會被禁。 */ m := map[int]user{ // 1: {"user1"}, } // m[1].name = "Tom" // ./main.go:16:12: cannot assign to struct field m[1].name in map fmt.Println(m) // 正確做法是完整替換 value 或使用指針。 u := m[1] u.name = "Tom" m[1] = u // 替換 value。 m2 := map[int]*user{ 1: &user{"user1"}, } m2[1].name = "Jack" // 返回的是指針復制品。透過指針修改原對象是允許的。 fmt.Println(m2) } ~~~ 輸出結果： ~~~ map[1:{user1}] map[1:0xc42000e1e0] ~~~ 可以在迭代時安全刪除鍵值。但如果期間有新增操作，那么就不知道會有什么意外了。 ~~~ package main import "fmt" func main() { for i := 0; i < 5; i++ { m := map[int]string{ 0: "a", 1: "a", 2: "a", 3: "a", 4: "a", 5: "a", 6: "a", 7: "a", 8: "a", 9: "a", } for k := range m { m[k+k] = "x" delete(m, k) } fmt.Println(m) } } ~~~ 輸出: //每次輸出都會變化 ~~~ map[36:x 28:x 32:x 2:x 8:x 10:x 12:x] map[12:x 6:x 16:x 28:x 4:x 10:x 72:x] map[12:x 14:x 16:x 18:x 20:x] map[18:x 10:x 14:x 4:x 6:x 16:x 24:x] map[12:x 16:x 4:x 40:x 14:x 18:x] ~~~