GO语言笔记--map

桃扇骨 2022-02-23 05:24 308阅读 0赞

# 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在字符串中最后出现的位置）不存在，或者<start(起始位置)->无需操作

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tvbmdzaHVhaTE5OTAwNTA1_size_16_color_FFFFFF_t_70]: /images/20220223/bb0307a6151b46e096da65c6ba0c95da.png