Go语言中的关联数组：深度解析Map类型及其应用

// 声明并初始化一个map，键为string类型，值为int类型
m := make(map[string]int)

// 也可以在声明时直接初始化键值对
ages := map[string]int{
    "Alice": 21,
    "Bob":   17,
}

// 声明一个nil map
var nilMap map[string]int // nilMap的值为nil
// fmt.Println(nilMap["test"]) // 对nil map的读操作会返回零值，但写操作会panic
// nilMap["test"] = 1 // 运行时panic

// 预分配容量的map，例如用于去重场景
var deDupMap = make(map[string]int, 1300000) // 为130万个元素预留空间

// 存储值
m["Alice"] = 21
m["Bob"] = 17

// 获取值
a := m["Alice"] // a 的值为 21
b := m["Bob"]   // b 的值为 17

value, ok := m["Alice"]   // value 为 21, ok 为 true
value, ok = m["Charlie"] // value 为 0 (int的零值), ok 为 false

fmt.Println("删除前:", m) // 输出: 删除前: map[Alice:21 Bob:17]
delete(m, "Bob")        // 删除键为"Bob"的条目
fmt.Println("删除后:", m) // 输出: 删除后: map[Alice:21]

// 再次尝试获取已删除的键
b, ok := m["Bob"]
fmt.Printf("获取 'Bob': 值=%d, 存在=%t\n", b, ok) // 输出: 获取 'Bob': 值=0, 存在=false

for k, v := range m {
    fmt.Printf("键: %s, 值: %d\n", k, v)
}
// 示例输出（顺序可能不同）:
// 键: Alice, 值: 21
// 键: Bob, 值: 17

// 只遍历键
for k := range m {
    fmt.Printf("键: %s\n", k)
}

// 只遍历值 (不常用，因为无法知道值对应的键)
for _, v := range m {
    fmt.Printf("值: %d\n", v)
}

heteroMap := make(map[string]interface{})
heteroMap["One"] = 1
heteroMap["Two"] = "Two"
heteroMap["IsGood"] = true
heteroMap["Pi"] = 3.14

fmt.Println(heteroMap) // 输出: map[IsGood:true One:1 Pi:3.14 Two:Two]

valOne := heteroMap["One"].(int)      // 断言为int类型
valTwo := heteroMap["Two"].(string)   // 断言为string类型
valBool := heteroMap["IsGood"].(bool) // 断言为bool类型

fmt.Printf("valOne: %d, valTwo: %s, valBool: %t\n", valOne, valTwo, valBool)

// 类型断言也支持“逗号 ok”模式，以安全地处理断言失败的情况
valPi, ok := heteroMap["Pi"].(float64)
if ok {
    fmt.Printf("valPi: %f\n", valPi)
} else {
    fmt.Println("valPi 断言失败")
}

// 尝试断言一个不存在的键或错误的类型会导致panic
// invalidVal := heteroMap["NonExistent"].(int) // panic
// wrongTypeVal := heteroMap["One"].(string)    // panic

for k, v := range heteroMap {
    switch u := v.(type) {
    case int:
        fmt.Printf("键 %q 是一个 int 类型，值为 %v。\n", k, u)
    case string:
        fmt.Printf("键 %q 是一个 string 类型，值为 %q。\n", k, u)
    case bool:
        fmt.Printf("键 %q 是一个 bool 类型，值为 %t。\n", k, u)
    default:
        fmt.Printf("键 %q 是一个未知类型，值为 %v。\n", k, u)
    }
}

// 示例：使用interface{}作为键
anyKeyMap := make(map[interface{}]int)
anyKeyMap[1] = 100
anyKeyMap["Two"] = 200
anyKeyMap[true] = 300
// anyKeyMap[[]int{1,2}] = 400 // 编译错误：slice不能作为map键

// 示例：使用map进行数据去重和计数
func countDuplicates(data []string) map[string]int {
    counts := make(map[string]int)
    for _, item := range data {
        counts[item]++ // 如果键不存在，则初始化为0后加1；如果存在，则直接加1
    }
    return counts
}

items := []string{"apple", "banana", "apple", "orange", "banana", "apple"}
itemCounts := countDuplicates(items)
fmt.Println("元素计数:", itemCounts) // 输出: 元素计数: map[apple:3 banana:2 orange:1]