1.说明

1）类似其他语言中的哈希表或者字典，以key-value形式存储数据

2）key必须是支持==或!=比较运算的类型，不可以是函数、map或slice

3）map查找比线性搜索快很多，但比使用所有房屋数据的类型慢100倍

4）map使用make()创建，支持:=这种简写方式

5）map使用哈希表，必须可以比较相等

6）除了slice，map,function的内建类型都可以错误key

7）Struct类型不包含上述字段，也可以作为key

2.操作

1）make([KeyType]value,cap),cap表示容量，可省略

2）超出容量时会自动扩容，但尽量提供一个合理的初始值

3）使用len()获取元素个数

4）获取元素：m[k]

5)key不存在时，获得value类型的初始值（零值）

6）用value, ok := m[key]来判断是否存在key

7)用delete删除一个key

8)用range遍历key，或者遍历key,value对

9）不保证遍历顺序，如需顺序，需要手动对key排序

10）使用len获取元素个数

注意：

1）键值对不存在时自动添加，使用delete()删除某键值对

2）使用for range对map和slice进行迭代操作

实例：

package main
import (
    "fmt"
)
func main() {
    m1 := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e",
        6: "f", 7: "g", 8: "h", 9: "i", 0: "j"}
    fmt.Println("m1", m1)
    m2 := make(map[string]int)
    for i, v := range m1 {
        m2[v] = i
    }
    fmt.Println("m2", m2)
}
输出：
API server listening at: 127.0.0.1:47449
m1 map[2:b 1:a 3:c 4:d 5:e 6:f 7:g 8:h 9:i 0:j]
m2 map[a:1 c:3 d:4 f:6 g:7 j:0 b:2 h:8 e:5 i:9]

实例二

package main
import "fmt"
func main() {
    m := map[string]string{
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    fmt.Println(m)
    //定义一个空map
    m2 := make(map[string]int) //m2 == empty map
    var m3 map[string]int // m3 == nil
    fmt.Println(m2, m3)
    //map遍历
    for k, v := range m {
        fmt.Println(k, v)
    }
}
输出：
API server listening at: 127.0.0.1:45987
map[name:ccmouse course:golang site:imooc quality:notbad]
map[] map[]
quality notbad
name ccmouse
course golang
site imooc

上述对m的输出前后顺序不一样，这是因为map在内存中是无序的

3.获取变量

package main
import "fmt"
func main() {
    m := map[string]string{
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    courseName := m["course"]
    fmt.Println(courseName)
    cName := m["cour"]
    fmt.Println(cName)
    fmt.Println("end")
}
输出：
API server listening at: 127.0.0.1:37028
golang
end

上述代码尤其注意k值拼写错误并不会报错，只是输出为空，这是因为零值，那么如何判断K值是否存在呢，看下面代码，获取时候获取一个状态就好了

package main
import "fmt"
func main() {
    m := map[string]string{
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    if courseName, ok := m["course"]; ok {
        fmt.Println(courseName)
    } else {
        fmt.Println("course key does not exit")
    }
    if cName, ok := m["cour"]; ok {
        fmt.Println(cName)
    } else {
        fmt.Println("cour key does not exit")
    }
}
输出：
API server listening at: 127.0.0.1:28373
golang
cour key does not exit

可以看出course存在直接输出，cour不存在则报错

4.删除

package main
import "fmt"
func main() {
    m := map[string]string{
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    fmt.Println(m)
    delete(m, "name")
    fmt.Println(m)
}
输出：
API server listening at: 127.0.0.1:43307
map[name:ccmouse course:golang site:imooc quality:notbad]
map[course:golang site:imooc quality:notbad]

前后输出对比发现name消失

综合实例：

1.寻找最长不含有重复字符串的子串

题目来自：https://leetcode.com/problems/longest-substring-without-repeating-characters/description/

题目描述如下图：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzaHVhaTE5OTAwNTA1_size_16_color_FFFFFF_t_70

例子：

abcabcbb->abc //最长的就是abc

bbbbb->b //最长为b

pwwkew->pwke //最长为pwke

算法描述：

对于每一个字母x

1）lastOccurred[x]（字母x在字符串中最后出现的位置）不存在，或者无需操作

2）lastOccurred[x] >= start ->更新start

3) 更新lastOccurred[x]，更新maxLength

package main
import "fmt"
func getStringLength(s string) int {
    lastOccurred := make(map[byte]int)
    start := 0//这就相当于一个游标，始终记录的时当前字符串的遍历位置
    maxLength := 0//记录的是已经查找过的不重复的字符串子串的长度
    for i, ch := range []byte(s) {
        lastI, ok := lastOccurred[ch]
        if ok && lastI >= start {
            start = lastI + 1
        }
        if i-start+1 > maxLength {
            maxLength = i - start + 1
        }
        lastOccurred[ch] = i
    }
    return maxLength
}
func main() {
    fmt.Println(getStringLength("abcabcbb"))
    fmt.Println(getStringLength("bbbbb"))
    fmt.Println(getStringLength("pwwkew"))
}
输出：
API server listening at: 127.0.0.1:36778
3
1
3