Go語言入門5－map映射

1. 類似其它語言中的哈希表或者字典，以key-value形式存儲數據
2. Key必須是支持==或!=比較運算的類型，不可以是函數、map或slice
3. Map查找比線性搜索快很多，但比使用索引訪問數據的類型慢100倍
4. Map使用make()創建，支持 := 這種簡寫方式

func main() {
	m := make(map[int]string)	//int是健的類型 string是值的類型
	m[1] = "ok"
	fmt.Println(m) 	//map[1:ok]
	a := m[1]
	fmt.Println(a)
	delete(m, 1)	//ok
	fmt.Println(m) 	//map[]
}

通過雙賦值檢測某個鍵是否存在：elem, ok := m[key]
若 key 在 m 中，ok 爲 true ；否則，ok 爲 false。
若 key 不在映射中，那麼 elem 是該映射元素類型的零值。
同樣的，當從映射中讀取某個不存在的鍵時，結果是映射的元素類型的零值。

func main() {
	m := make(map[string]int)

	m["Answer"] = 42
	fmt.Println("The value:", m["Answer"])	//The value: 42

	delete(m, "Answer")
	fmt.Println("The value:", m["Answer"])	//The value: 0

	v, ok := m["Answer"]
	fmt.Println("The value:", v, "Present?", ok)	//The value: 0 Present? false
}

當有多個map嵌套map的時候，每一級的map都要單獨的初始化，否則運行時會報錯。

//返回值爲兩個時 第二個參數爲bool 類型 可以判斷第二個參數來判斷第一個參數是否正確
func main() {
	m := make(map[int]map[int]string)
	a, ok := m[2][1]
	fmt.Println(a, ok) // false
	if !ok {
		m[2] = make(map[int]string)
	}
	m[2][1] = "good"
	a, ok = m[2][1]
	fmt.Println(a, ok)good true
}

遍歷（v只是一個拷貝，對v的任何操作都不會影響本身的slice）

func main() {
	sm := make([]map[int]string, 5)
	for _, v := range sm {
		v = make(map[int]string, 1)
		v[1] = "ok"
		fmt.Println(v)
	}
	fmt.Println(sm)
}

結果：

map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
[map[] map[] map[] map[] map[]]

如果想改變本身的slice，則需要用i，例：

func main() {
	sm := make([]map[int]string, 5)
	for i := range sm {
		sm[i] = make(map[int]string, 1)
		sm[i][1] = "ok"
		fmt.Println(sm[i])
	}
	fmt.Println(sm)
}

結果

map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
map[1:ok]
[map[1:ok] map[1:ok] map[1:ok] map[1:ok] map[1:ok]]

循環map是無序的,不能夠直接排序。

func main() {
	m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "f"}
	s := make([]int, len(m))
	i := 0
	for k, _ := range m {
		s[i] = k
		i++
	}
	fmt.Println(s)
}

每次執行後的結果都不相同，這也就證明了map是無序的

➜ gogogo go run demo.go
[5 1 2 3 4]
➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo go run demo.go
[3 4 5 1 2]
➜ gogogo

下面我們通過導入sort包間接的讓map有序

func main() {
	m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "f"}
	s := make([]int, len(m))
	i := 0
	for k, _ := range m {
		s[i] = k
		i++
	}
	sort.Ints(s)
	fmt.Println(s) //[1 2 3 4 5]
}

每次執行後的結果相同了，這就間接實現了map的有序

➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo go run demo.go
[1 2 3 4 5]
➜ gogogo

demo：嘗試將類型爲map[int]string的鍵和值進行交換，變成類型map[string]int

func main() {
	m1 := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "f"}
	fmt.Println(m1)
	m2 := make(map[string]int)
	for k, v := range m1 {
		m2[v] = k
	}
	fmt.Println(m2)
}

結果

map[1:a 2:b 3:c 4:d 5:f]
map[b:2 c:3 d:4 f:5 a:1]