Map操作 #

一、添加元素 #

1.1 基本添加 #

m := make(map[string]int)
m["one"] = 1
m["two"] = 2

1.2 批量添加 #

m := make(map[string]int)
data := map[string]int{"a": 1, "b": 2, "c": 3}

for k, v := range data {
    m[k] = v
}

1.3 条件添加 #

func addIfNotExists(m map[string]int, key string, value int) {
    if _, exists := m[key]; !exists {
        m[key] = value
    }
}

二、获取元素 #

2.1 直接获取 #

m := map[string]int{"one": 1, "two": 2}

v := m["one"]
fmt.Println(v)  // 1

2.2 获取不存在的键 #

m := map[string]int{"one": 1}

v := m["three"]
fmt.Println(v)  // 0（零值）

2.3 检查键是否存在 #

m := map[string]int{"one": 1, "two": 2}

if v, ok := m["one"]; ok {
    fmt.Println("存在:", v)
} else {
    fmt.Println("不存在")
}

2.4 获取或默认值 #

func getOrDefault(m map[string]int, key string, defaultValue int) int {
    if v, ok := m[key]; ok {
        return v
    }
    return defaultValue
}

m := map[string]int{"one": 1}
fmt.Println(getOrDefault(m, "one", 0))    // 1
fmt.Println(getOrDefault(m, "two", 100))  // 100

三、修改元素 #

3.1 直接修改 #

m := map[string]int{"one": 1}
m["one"] = 10
fmt.Println(m)  // map[one:10]

3.2 条件修改 #

func incrementIfExists(m map[string]int, key string) {
    if v, ok := m[key]; ok {
        m[key] = v + 1
    }
}

3.3 原子更新 #

func atomicUpdate(m map[string]int, key string, update func(int) int) {
    m[key] = update(m[key])
}

m := map[string]int{"count": 10}
atomicUpdate(m, "count", func(v int) int { return v * 2 })
fmt.Println(m["count"])  // 20

四、删除元素 #

4.1 删除单个元素 #

m := map[string]int{"one": 1, "two": 2, "three": 3}
delete(m, "two")
fmt.Println(m)  // map[one:1 three:3]

4.2 删除不存在的键 #

m := map[string]int{"one": 1}
delete(m, "notexist")  // 不会报错

4.3 批量删除 #

func deleteKeys(m map[string]int, keys []string) {
    for _, key := range keys {
        delete(m, key)
    }
}

4.4 清空Map #

func clearMap(m map[string]int) {
    for key := range m {
        delete(m, key)
    }
}

// 或重新赋值
m = make(map[string]int)

五、查询操作 #

5.1 检查键是否存在 #

func containsKey(m map[string]int, key string) bool {
    _, ok := m[key]
    return ok
}

5.2 检查值是否存在 #

func containsValue(m map[string]int, value int) bool {
    for _, v := range m {
        if v == value {
            return true
        }
    }
    return false
}

5.3 查找键 #

func findKey(m map[string]int, value int) (string, bool) {
    for k, v := range m {
        if v == value {
            return k, true
        }
    }
    return "", false
}

5.4 过滤 #

func filter(m map[string]int, predicate func(string, int) bool) map[string]int {
    result := make(map[string]int)
    for k, v := range m {
        if predicate(k, v) {
            result[k] = v
        }
    }
    return result
}

m := map[string]int{"a": 1, "b": 2, "c": 3}
filtered := filter(m, func(k string, v int) bool {
    return v > 1
})
fmt.Println(filtered)  // map[b:2 c:3]

六、批量操作 #

6.1 合并Map #

func merge(m1, m2 map[string]int) map[string]int {
    result := make(map[string]int)
    for k, v := range m1 {
        result[k] = v
    }
    for k, v := range m2 {
        result[k] = v
    }
    return result
}

6.2 复制Map #

func copyMap(m map[string]int) map[string]int {
    result := make(map[string]int, len(m))
    for k, v := range m {
        result[k] = v
    }
    return result
}

6.3 比较Map #

func equal(m1, m2 map[string]int) bool {
    if len(m1) != len(m2) {
        return false
    }
    for k, v := range m1 {
        if v2, ok := m2[k]; !ok || v != v2 {
            return false
        }
    }
    return true
}

6.4 获取所有键 #

func keys(m map[string]int) []string {
    result := make([]string, 0, len(m))
    for k := range m {
        result = append(result, k)
    }
    return result
}

6.5 获取所有值 #

func values(m map[string]int) []int {
    result := make([]int, 0, len(m))
    for _, v := range m {
        result = append(result, v)
    }
    return result
}

七、实际应用 #

7.1 计数器 #

func countFrequency(items []string) map[string]int {
    counts := make(map[string]int)
    for _, item := range items {
        counts[item]++
    }
    return counts
}

7.2 索引构建 #

func buildIndex(items []Item) map[string]Item {
    index := make(map[string]Item)
    for _, item := range items {
        index[item.ID] = item
    }
    return index
}

7.3 缓存实现 #

type Cache struct {
    data map[string]interface{}
    mu   sync.RWMutex
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    v, ok := c.data[key]
    return v, ok
}

func (c *Cache) Set(key string, value interface{}) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}

八、总结 #

Map操作要点：

操作	方法
添加	m[key] = value
获取	v := m[key]
检查存在	v, ok := m[key]
修改	m[key] = newValue
删除	delete(m, key)

关键点：

零值返回：不存在的键返回零值
ok模式：使用v, ok := m[key]检查存在
delete安全：删除不存在的键不会报错
批量操作：使用循环进行批量操作
并发安全：需要加锁保证并发安全