Map

创建map：

func main() {
    // 创建方式1
    m := map[string]string {
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    fmt.Println(m) // map[quality:notbad name:ccmouse course:golang site:imooc]
    // 创建方式2
    m2 := make(map[string]int) // m2 == empty map
    fmt.Println(m2) // map[] 
    // 创建方式3
    var m3 map[string]int // m3 == nil
    fmt.Println(m3) // map[]
}

map的遍历：
map是无序的，因此不能保证遍历顺序。如需顺序，需手动对key排序。

func main() {
    m := map[string]string {
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    for k, v := range m {
        fmt.Println(k, v)
    }
    // 只获取key
    for k := range m {
        fmt.Println(k)
    }
    // 只获取value
    for _, v := range m {
        fmt.Println(v)
    }
}

获取values：

func main() {
    m := map[string]string {
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    courseName := m["course"]
    // 当key不存在时，map[key]将会获得value类型的ZeroValue
    causeName := m["cause"] 
    fmt.Println(causeName) // 空串""（value类型为string，因此获得string类型的ZeroValue空串）

    // 用value, ok := m[key] 来检查key是否存在
    courseName, ok := m["course"]
    fmt.Println(courseName, ok) // golang true
    if causeName, ok := m["cause"]; ok {
        fmt.Println(causeName)
    } else {
        fmt.Println("key does not exist")
    } 
}

删除values：

func main() {
    m := map[string]string {
        "name": "ccmouse",
        "course": "golang",
        "site": "imooc",
        "quality": "notbad",
    }
    delete(m, "name")
    name, ok := m["name"]
    fmt.Println(name, ok) // ""(空串) false
}

map的key的类型要求：
map使用哈希表，因此key必须是可以判断是否相等的类型。
内建类型，只要不是slice，map，function，就可以作为key。
Struct类型只要不包括slice，map和function字段，就可以作为key。（Struct类型是否可以作为key的检查在编译时进行）

map例题：寻找最长的不重复子串

package main

func lengthOfNonRepeatingSubStr(s string) int {
    // 记录每个字符最后出现的位置
    lastOccurred := make(map[byte]int)
    start := 0
    maxLength := 0

    for i, ch := range []byte(s) {
        if lastI, ok := lastOccurred[ch]; ok && lastI >= start {
            start = lastI + 1
        }
        if i - start + 1 > maxLength {
            maxLength = i - start + 1
        }
        lastOccurred[ch] = i
    }

    return maxLength
}