07- Go语言基础之map

Go 语言中提供的映射管理为map , 其内部结构使用散列表(hash) 实现.

map 是一种无序的 基于key-value 的数据结构, Go 语言中的map 是引用类型, 必须初始化才能使用.

map 定义

语法:

  1. map[keyType]valueType
  • keyType: 表示键的类型.
  • valueType: 表示键对应值得类型

map 类型的变量初始值为nil. 需要使用make()函数来分配内存.

  1. make(map[keyType]valueType, [cap])

其中cap 表示 map 的容量, 改参数虽然不是必须的, 但是我们应该在初始化map 的时候就为其指定一个合适ide容量.

map基本使用

map 中的数据都是成对出现的.

  1. func main() {
  2.     score := make(map[string]int, 8)
  3.     score["张三"] = 90
  4.     score["李四"] = 100
  5.     fmt.Println(score)
  6.     fmt.Println(score["张三"])
  7.     fmt.Printf("type of a:%T\n", score)
  8. }

输出:

  1. map[张三:90 李四:100]
  2. 90
  3. type of a:map[string]int

map 也支持在声明的时候填充元素.

  1. func main() {
  2.     score := map[string]int{
  3.         "张三":10,
  4.         "李四":20,
  5.     }
  6. }

判断某个键是否存在

  1. value, ok := map[key]

举例:

  1. func main() {
  2.     score := map[string]int{
  3.         "张三":10,
  4.         "李四":20,
  5.     }
  6.     v,ok := score["王五"]
  7.     if ok {
  8.         fmt.Println(v)
  9.     } else {
  10.         fmt.Println("查无此人")
  11.     }
  12. }

map的遍历

Go 语言中使用 for range 遍历 map

  1. func main() {
  2.     score := map[string]int{
  3.         "张三":10,
  4.         "李四":20,
  5.     }
  6.     for k, v := range score {
  7.         fmt.Println(k,v)
  8.     }
  9. }

当我们只想遍历key的时候, 可以按照下面写法:

  1. func main() {
  2.     score := map[string]int{
  3.         "张三":10,
  4.         "李四":20,
  5.     }
  6.     for k := range score {
  7.         fmt.Println(k)
  8.     }
  9. }

注意

遍历map 元素的顺序与添加键值对的顺序无关.

删除键值对 delete() 函数

使用delete() 内建函数从map 中删除键值对

  1. delete(map, key)
  • map就是要被删除键值对的map
  • key, 要删除键值对的key
  1. func main() {
  2.     score := map[string]int{
  3.         "张三":10,
  4.         "李四":20,
  5.     }
  6.     delete(score, "李四")
  7.     for k := range score {
  8.         fmt.Println(k)
  9.     }
  10. }

按照指定顺序遍历map

  1. func main() {
  2.     rand.Seed(time.Now().UnixNano()) //  初始化随机种子
  3.     var score = make(map[string]int, 200)
  4.     for i :=0; i<100; i++ {
  5.         key := fmt.Sprintf("stu%02d", i)
  6.         value := rand.Intn(100)
  7.         score[key] = value
  8.     }
  9.     var keys = make([]string, 0, 200)
  10.     for key := range score {
  11.         keys = append(keys, key)
  12.     }
  13.     sort.Strings(keys)
  14.     for _, key := range keys {
  15.         fmt.Println(score[key])
  16.     }
  18. }

元素为map类型的切片

  2. func sliceMap() {
  3.     var mapSlice = make([]map[string]string, 3)
  4.     for i, v := range mapSlice {
  5.         fmt.Printf("index :%d value: %v \n", i, v)
  6.     }
  7.     fmt.Println("after init")
  8.     // 对切片中的map 进行初始化
  9.     mapSlice[0] = make(map[string]string, 10)
  10.     mapSlice[0]["name"] = "七里塘"
  11.     mapSlice[0]["age"] = "18"
  12.     mapSlice[0]["address"] = "仙界"
  13.     for index, value := range mapSlice {
  14.         fmt.Printf("index:%d value: %v \n", index, value)
  15.     }
  17. }