Go：map声明和定义

map声明和定义

1. map类型是⼀个key-value的数据结构。

//var a map[key的类型]value类型
var a map[string]int
var b map[int]string
var c map[float32]string

注意：map必须初始化才能使⽤，否则panic

2. map类型的变量默认初始化为nil，需要使⽤make分配map内存

package main
import (
     "fmt"
)
func main() {
     var a map[string]int
     if a == nil {
         fmt.Println("map is nil. Going to make one.")
         A = make(map[string]int)
     }
}

3. map插⼊操作

package main
import (
 "fmt"
)
func main() {
     a := make(map[string]int)
     a["steve"] = 12000
     a["jamie"] = 15000
     a["mike"] = 9000
     fmt.Println(“a map contents:", a)
}

4. 声明时进⾏初始化

package main
import (
     "fmt"
)
func main() {
     a := map[string]int {
     "steve": 12000,
     "jamie": 15000,
     }
     a[“mike"] = 9000
     fmt.Println(“a map contents:", a)
}

5. 通过key访问map中的元素

package main
import (
     "fmt"
)
func main() {
     a := map[string]int{
         "steve": 12000,
         "jamie": 15000,
     }
     a["mike"] = 9000
     b := "jamie"
     fmt.Println("Salary of", b, "is", a[b])
}

5. 通过key访问map中的元素

package main
import (
     "fmt"
)
func main() {
     a := map[string]int{
         "steve": 12000,
         "jamie": 15000,
     }
     a["mike"] = 9000
     b := “123”
     fmt.Println("Salary of", b, "is", a[b])
}

6. 如何判断map指定的key是否存在? value, ok := map[key]

package main
import (
     "fmt"
)

func main() {
     a := map[string]int{
         "steve": 12000,
         "jamie": 15000,
     }
     a["mike"] = 9000
     b := "joe"
     value, ok := a[b]
     if ok == true {
         fmt.Println("Salary of", b, "is", value)
     } else {
         fmt.Println(b,”not found")
     }
}

7. map遍历操作

package main
import (
     "fmt"
)
func main() {
     a := map[string]int{
         "steve": 12000,
         "jamie": 15000,
     }
     a["mike"] = 9000
     fmt.Println("All items of a map")
     for key, value := range a {
         fmt.Printf("personSalary[%s] = %d\n", key, value)
     }
}

8. map删除元素

package main
import (
     "fmt"
)
func main() {
     a := map[string]int{
         "steve": 12000,
         "jamie": 15000,
     }
     a["mike"] = 9000
     fmt.Println("map before deletion", a)
     delete(a, "steve")
     fmt.Println("map after deletion", a)
}

9. map的⻓度

package main
import (
     "fmt"
)
func main() {
     a := map[string]int{
         "steve": 12000,
         "jamie": 15000,
     }
     a["mike"] = 9000
     fmt.Println("length is", len(a))
}

10.map是引⽤类型

package main
import (
     "fmt"
)
func main() {
     a := map[string]int{
         "steve": 12000,
         "jamie": 15000,
     }
     a["mike"] = 9000
     fmt.Println(“origin map", a)
     b := a
     b["mike"] = 18000
     fmt.Println(“a map changed", a)
}

11.默认情况下，map并不是按照key有序进⾏遍历的

package main
import (
    "fmt"
)
func main() {
    var a map[string]int = make(map[string]int, 10)
    for i := 0; i < 10; i++ {
        key := fmt.Sprintf("key%d", i)
        a[key] = i
    }
    for key, value := range a {
        fmt.Printf("key:%s = %d\n", key, value)
    }
}

12. map按照key进⾏排序，遍历

package main
import (
     "fmt"
     "sort"
)
func main() {
     var a map[string]int = make(map[string]int, 10)
     for i := 0; i < 10; i++ {
         key := fmt.Sprintf("key%d", i)
         a[key] = i
     }
     var keys []string
     for key, _ := range a {
         keys = append(keys, key)
     }
     sort.Strings(keys)
     for _, key := range keys {
     fmt.Printf("key:%s=%d\n", key, a[key])
 }
}

13. map类型的切⽚

package main
import (
    "fmt"
)
func main() {
    var mapSlice []map[string]int
    mapSlice = make([]map[string]int, 5)
    fmt.Println("before map init")
    for index, value := range mapSlice {
        fmt.Printf("index:%d value:%v\n", index, value)
    }
    fmt.Println()
    mapSlice[0] = make(map[string]int, 10)
    mapSlice[0]["a"] = 1000
    mapSlice[0]["b"] = 2000
    mapSlice[0]["c"] = 3000
    mapSlice[0]["d"] = 4000
    mapSlice[0]["e"] = 5000

    fmt.Println("after map init")
    for index, value := range mapSlice {
        fmt.Printf("index:%d value:%v\n", index, value)
    }
}