Go语言中提供的映射关系容器为map，其内部使用散列表（hash）实现。

map

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

map定义与使用make初始化

  • Go语言中 map的定义语法如下：

    1. map[KeyType]ValueType

    其中，

    • KeyType:表示键的类型。
    • ValueType:表示键对应的值的类型。

  • map类型的变量默认初始值为nil，需要使用make()函数来分配内存。语法为：

    1. make(map[KeyType]ValueType, [cap])

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

    map基本使用

    map中的数据都是成对出现的，map的基本使用示例代码如下：

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

    输出：

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

    map也支持在声明的时候填充元素，例如：

    1. func main() {
    2.   userInfo := map[string]string{
    3.       "username": "沙河小王子",
    4.       "password": "123456",
    5.   }
    6.   fmt.Println(userInfo) //
    7. }

    判断某个键是否存在

    若果key值不存在，则得到ValueType对应类型的零值。
    Go语言中有个判断map中键是否存在的特殊写法，格式如下:

    1. value, ok := map[key] // value和是否存在的布尔值

    举个例子：

    1. func main() {
    2.   scoreMap := make(map[string]int)
    3.   scoreMap["张三"] = 90
    4.   scoreMap["小明"] = 100
    5.   // 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值
    6.   v, ok := scoreMap["张三"]
    7.   if ok {
    8.       fmt.Println(v)
    9.   } else {
    10.       fmt.Println("查无此人")
    11.   }
    12. }

    map的遍历

    Go语言中使用for range遍历map。

    1. func main() {
    2.   scoreMap := make(map[string]int)
    3.   scoreMap["张三"] = 90
    4.   scoreMap["小明"] = 100
    5.   scoreMap["娜扎"] = 60
    6.   for k, v := range scoreMap {
    7.       fmt.Println(k, v) // key & value
    8.   }
    9. }

    但我们只想遍历key的时候，可以按下面的写法：

    1. // 只遍历key可以省略value；只遍历value使用匿名变量存放key
    2. func main() {
    3.   scoreMap := make(map[string]int)
    4.   scoreMap["张三"] = 90
    5.   scoreMap["小明"] = 100
    6.   scoreMap["娜扎"] = 60
    7.   for k := range scoreMap {
    8.       fmt.Println(k)
    9.   }
    10. }

    注意： 遍历map时的元素顺序与添加键值对的顺序无关。

    使用delete()函数删除键值对

    使用delete()内建函数从map中删除一组键值对，delete()函数的格式如下：

    1. delete(map, key)

    其中，

  • map:表示要删除键值对的map

  • key:表示要删除的键值对的键
  • 删除不存在的key值或map为nil 不做任何操作

示例代码如下：

  1. func main(){
  2.     scoreMap := make(map[string]int)
  3.     scoreMap["张三"] = 90
  4.     scoreMap["小明"] = 100
  5.     scoreMap["娜扎"] = 60
  6.     delete(scoreMap, "小明")//将小明:100从map中删除
  7.     for k,v := range scoreMap{
  8.         fmt.Println(k, v)
  9.     }
  10. }

按照指定顺序遍历map

原理：把map的key值append进入一个切片，对切片排序完成对map的排序

  1. func main() {
  2.     rand.Seed(time.Now().UnixNano()) //初始化随机数种子（当前时间的ns）？？？
  4.     var scoreMap = make(map[string]int, 200)
  5.     for i := 0; i < 100; i++ {
  6.         key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
  7.         value := rand.Intn(100)          //生成0~99的随机整数
  8.         scoreMap[key] = value
  9.     }
  10.     //取出map中的所有key存入切片keys
  11.     var keys = make([]string, 0, 200)
  12.     for key := range scoreMap {
  13.         keys = append(keys, key)
  14.     }
  15.     //对切片进行排序
  16.     sort.Strings(keys)
  17.     //按照排序后的key遍历map
  18.     for _, key := range keys {
  19.         fmt.Println(key, scoreMap[key])
  20.     }
  21. }

元素为map类型的切片

下面的代码演示了切片中的元素为map类型时的操作：

  1. func main() {
  2.     var mapSlice = make([]map[string]string, 3)// 1. 类型为map[string]string的切片
  3.     for index, value := range mapSlice {
  4.         fmt.Printf("index:%d value:%v\n", index, value)// 2. 此时value都是map类型的零值空map
  5.     }
  6.     fmt.Println("after init")
  7.     // 3. 对切片中的map元素进行初始化-把切片元素赋值为map进行初始化
  8.     mapSlice[0] = make(map[string]string, 10)
  9.     mapSlice[0]["name"] = "小王子"// 4. 修改下标为0的map
  10.     mapSlice[0]["password"] = "123456"
  11.     mapSlice[0]["address"] = "沙河"
  12.     // 此时切片为：[map[address:沙河 name:小王子 password:123456] map[] map[]]
  13.     for index, value := range mapSlice {
  14.         fmt.Printf("index:%d value:%v\n", index, value)
  15.     }
  16. }

值为切片类型的map

下面的代码演示了map中值为切片类型的操作：

  1. func main() {
  2.     var sliceMap = make(map[string][]string, 3)// map
  3.     fmt.Println(sliceMap)
  4.     fmt.Println("after init")
  5.     key := "中国"
  6.     value, ok := sliceMap[key]
  7.     if !ok {
  8.         value = make([]string, 0, 2) // 切片
  9.     }
  10.     value = append(value, "北京", "上海")
  11.     sliceMap[key] = value
  12.     fmt.Println(sliceMap)
  13. }

练习题

  1. 写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。

为什么新建一个长度为0的切片？重点：若新建有长度的切片，内部会有int的零值0。此处本来就是想要一个空切片，等待插入即可。

  1.     str := "how do you do"
  2.     s1 := strings.Split(str, " ") // 切割成切片类型：[how do you do]
  3.     type Map map[string][]int
  4.     m := make(Map) // 初始化map
  5.     for i, v := range s1 {
  6.         _, ok := m[v] // 遍历切片s1，看看v是否是m的key值
  7.         if ok {// 是：表示已经初始化切片，直接append下标
  8.             m[v] = append(m[v], i)
  9.         } else {// 不是：新建一个长度为0的切片和下标通过append添加->初始化切片并插入第一次出现的下标
  10.             m[v] = append(make([]int, 0, 10), i)
  11.         }
  12.     }
  13.     for k, v := range m {// 遍历map得到结果：map[do:[1 3] how:[0] you:[2]]
  14.         fmt.Println(k, len(v))
  15.     }
  1. 观察下面代码，写出最终的打印结果。
    1. func main() {
    2.  type Map map[string][]int
    3.  m := make(Map)
    4.  s := []int{1, 2}
    5.  s = append(s, 3)
    6.  fmt.Printf("%+v\n", s)// [1,2,3] 第一次是len为3的切片
    7.  m["q1mi"] = s
    8.  s = append(s[:1], s[2:]...)// 第二次是len为2的切片
    9.  fmt.Printf("%+v\n", s)// [1,3]
    10.  fmt.Printf("%+v\n", m["q1mi"]) // map是引用类型，value变化了，但是第三项没有变化
    11. }