722 lines
17 KiB
Go
722 lines
17 KiB
Go
/*
|
||
03-maps.go - Go 语言映射详解
|
||
|
||
学习目标：
|
||
1. 理解映射的概念和特性
|
||
2. 掌握映射的创建和初始化
|
||
3. 学会映射的基本操作
|
||
4. 了解映射的内部实现
|
||
5. 掌握映射的实际应用场景
|
||
|
||
知识点：
|
||
- 映射的定义和特性
|
||
- 映射的创建方式
|
||
- 映射的增删改查操作
|
||
- 映射的遍历
|
||
- 映射的零值和比较
|
||
- 映射作为集合使用
|
||
- 映射的并发安全问题
|
||
*/
|
||
|
||
package main
|
||
|
||
import (
|
||
"fmt"
|
||
)
|
||
|
||
func main() {
|
||
fmt.Println("=== Go 语言映射详解 ===\n")
|
||
|
||
// 演示映射的基本概念
|
||
demonstrateBasicMaps()
|
||
|
||
// 演示映射的创建方式
|
||
demonstrateMapCreation()
|
||
|
||
// 演示映射的基本操作
|
||
demonstrateMapOperations()
|
||
|
||
// 演示映射的遍历
|
||
demonstrateMapIteration()
|
||
|
||
// 演示映射的高级操作
|
||
demonstrateAdvancedMapOperations()
|
||
|
||
// 演示映射作为集合使用
|
||
demonstrateMapAsSet()
|
||
|
||
// 演示映射的实际应用
|
||
demonstratePracticalApplications()
|
||
}
|
||
|
||
// demonstrateBasicMaps 演示映射的基本概念
|
||
func demonstrateBasicMaps() {
|
||
fmt.Println("1. 映射的基本概念:")
|
||
|
||
// 映射的基本特性
|
||
fmt.Printf(" 映射的基本特性:\n")
|
||
fmt.Printf(" - 键值对的无序集合\n")
|
||
fmt.Printf(" - 键必须是可比较的类型\n")
|
||
fmt.Printf(" - 引用类型，零值是 nil\n")
|
||
fmt.Printf(" - 动态大小，可以增长和缩减\n")
|
||
fmt.Printf(" - 不能直接比较，只能与 nil 比较\n")
|
||
|
||
// 基本映射示例
|
||
fmt.Printf(" 基本映射示例:\n")
|
||
|
||
var m map[string]int // 声明映射，零值为 nil
|
||
fmt.Printf(" 声明映射: %v\n", m)
|
||
fmt.Printf(" 是否为 nil: %t\n", m == nil)
|
||
fmt.Printf(" 长度: %d\n", len(m))
|
||
|
||
// 初始化映射
|
||
scores := map[string]int{
|
||
"Alice": 95,
|
||
"Bob": 87,
|
||
"Charlie": 92,
|
||
}
|
||
fmt.Printf(" 初始化映射: %v\n", scores)
|
||
fmt.Printf(" 长度: %d\n", len(scores))
|
||
|
||
// 访问映射元素
|
||
fmt.Printf(" Alice的分数: %d\n", scores["Alice"])
|
||
fmt.Printf(" 不存在的键: %d\n", scores["David"]) // 返回零值
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateMapCreation 演示映射的创建方式
|
||
func demonstrateMapCreation() {
|
||
fmt.Println("2. 映射的创建方式:")
|
||
|
||
// 方式1: 字面量创建
|
||
fmt.Printf(" 方式1 - 字面量创建:\n")
|
||
colors := map[string]string{
|
||
"red": "#FF0000",
|
||
"green": "#00FF00",
|
||
"blue": "#0000FF",
|
||
}
|
||
fmt.Printf(" colors: %v\n", colors)
|
||
|
||
// 方式2: make 函数创建
|
||
fmt.Printf(" 方式2 - make 函数创建:\n")
|
||
ages := make(map[string]int)
|
||
ages["Alice"] = 25
|
||
ages["Bob"] = 30
|
||
fmt.Printf(" ages: %v\n", ages)
|
||
|
||
// 方式3: 空映射字面量
|
||
fmt.Printf(" 方式3 - 空映射字面量:\n")
|
||
empty := map[string]int{}
|
||
fmt.Printf(" empty: %v (len=%d)\n", empty, len(empty))
|
||
fmt.Printf(" 是否为 nil: %t\n", empty == nil)
|
||
|
||
// 方式4: 带容量提示的 make
|
||
fmt.Printf(" 方式4 - 带容量提示的 make:\n")
|
||
large := make(map[string]int, 100) // 容量提示，不是限制
|
||
fmt.Printf(" large: %v (len=%d)\n", large, len(large))
|
||
|
||
// 不同类型的映射
|
||
fmt.Printf(" 不同类型的映射:\n")
|
||
|
||
// 整数键
|
||
intMap := map[int]string{1: "one", 2: "two", 3: "three"}
|
||
fmt.Printf(" 整数键: %v\n", intMap)
|
||
|
||
// 结构体值
|
||
type Person struct {
|
||
Name string
|
||
Age int
|
||
}
|
||
|
||
people := map[string]Person{
|
||
"p1": {"Alice", 25},
|
||
"p2": {"Bob", 30},
|
||
}
|
||
fmt.Printf(" 结构体值: %v\n", people)
|
||
|
||
// 切片值
|
||
groups := map[string][]string{
|
||
"fruits": {"apple", "banana", "cherry"},
|
||
"vegetables": {"carrot", "broccoli", "spinach"},
|
||
}
|
||
fmt.Printf(" 切片值: %v\n", groups)
|
||
|
||
// 映射值
|
||
nested := map[string]map[string]int{
|
||
"math": {"Alice": 95, "Bob": 87},
|
||
"english": {"Alice": 92, "Bob": 89},
|
||
}
|
||
fmt.Printf(" 嵌套映射: %v\n", nested)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateMapOperations 演示映射的基本操作
|
||
func demonstrateMapOperations() {
|
||
fmt.Println("3. 映射的基本操作:")
|
||
|
||
// 创建映射
|
||
inventory := make(map[string]int)
|
||
|
||
// 添加/更新元素
|
||
fmt.Printf(" 添加/更新元素:\n")
|
||
inventory["apples"] = 50
|
||
inventory["bananas"] = 30
|
||
inventory["oranges"] = 25
|
||
fmt.Printf(" 添加水果: %v\n", inventory)
|
||
|
||
// 更新现有元素
|
||
inventory["apples"] = 45
|
||
fmt.Printf(" 更新苹果数量: %v\n", inventory)
|
||
|
||
// 读取元素
|
||
fmt.Printf(" 读取元素:\n")
|
||
apples := inventory["apples"]
|
||
fmt.Printf(" 苹果数量: %d\n", apples)
|
||
|
||
// 检查键是否存在
|
||
fmt.Printf(" 检查键是否存在:\n")
|
||
value, exists := inventory["bananas"]
|
||
fmt.Printf(" bananas存在: %t, 值: %d\n", exists, value)
|
||
|
||
value, exists = inventory["grapes"]
|
||
fmt.Printf(" grapes存在: %t, 值: %d\n", exists, value)
|
||
|
||
// 删除元素
|
||
fmt.Printf(" 删除元素:\n")
|
||
fmt.Printf(" 删除前: %v\n", inventory)
|
||
delete(inventory, "oranges")
|
||
fmt.Printf(" 删除oranges后: %v\n", inventory)
|
||
|
||
// 删除不存在的键（安全操作）
|
||
delete(inventory, "grapes")
|
||
fmt.Printf(" 删除不存在的键后: %v\n", inventory)
|
||
|
||
// 批量操作
|
||
fmt.Printf(" 批量操作:\n")
|
||
newItems := map[string]int{
|
||
"pears": 20,
|
||
"grapes": 35,
|
||
"kiwis": 15,
|
||
}
|
||
|
||
// 批量添加
|
||
for key, value := range newItems {
|
||
inventory[key] = value
|
||
}
|
||
fmt.Printf(" 批量添加后: %v\n", inventory)
|
||
|
||
// 清空映射
|
||
fmt.Printf(" 清空映射:\n")
|
||
for key := range inventory {
|
||
delete(inventory, key)
|
||
}
|
||
fmt.Printf(" 清空后: %v (len=%d)\n", inventory, len(inventory))
|
||
|
||
fmt.Println()
|
||
}//
|
||
demonstrateMapIteration 演示映射的遍历
|
||
func demonstrateMapIteration() {
|
||
fmt.Println("4. 映射的遍历:")
|
||
|
||
students := map[string]int{
|
||
"Alice": 95,
|
||
"Bob": 87,
|
||
"Charlie": 92,
|
||
"David": 78,
|
||
"Eve": 89,
|
||
}
|
||
|
||
// 遍历键值对
|
||
fmt.Printf(" 遍历键值对:\n")
|
||
for name, score := range students {
|
||
fmt.Printf(" %s: %d\n", name, score)
|
||
}
|
||
|
||
// 只遍历键
|
||
fmt.Printf(" 只遍历键:\n")
|
||
for name := range students {
|
||
fmt.Printf(" 学生: %s\n", name)
|
||
}
|
||
|
||
// 只遍历值
|
||
fmt.Printf(" 只遍历值:\n")
|
||
for _, score := range students {
|
||
fmt.Printf(" 分数: %d\n", score)
|
||
}
|
||
|
||
// 注意：映射遍历顺序是随机的
|
||
fmt.Printf(" 注意: 映射遍历顺序是随机的\n")
|
||
fmt.Printf(" 多次遍历可能得到不同的顺序\n")
|
||
|
||
// 有序遍历
|
||
fmt.Printf(" 有序遍历（按键排序）:\n")
|
||
|
||
// 收集所有键
|
||
var names []string
|
||
for name := range students {
|
||
names = append(names, name)
|
||
}
|
||
|
||
// 排序键
|
||
sort.Strings(names)
|
||
|
||
// 按排序后的键遍历
|
||
for _, name := range names {
|
||
fmt.Printf(" %s: %d\n", name, students[name])
|
||
}
|
||
|
||
// 按值排序遍历
|
||
fmt.Printf(" 按分数排序遍历:\n")
|
||
|
||
type StudentScore struct {
|
||
Name string
|
||
Score int
|
||
}
|
||
|
||
var studentList []StudentScore
|
||
for name, score := range students {
|
||
studentList = append(studentList, StudentScore{name, score})
|
||
}
|
||
|
||
// 按分数排序
|
||
sort.Slice(studentList, func(i, j int) bool {
|
||
return studentList[i].Score > studentList[j].Score
|
||
})
|
||
|
||
for _, student := range studentList {
|
||
fmt.Printf(" %s: %d\n", student.Name, student.Score)
|
||
}
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateAdvancedMapOperations 演示映射的高级操作
|
||
func demonstrateAdvancedMapOperations() {
|
||
fmt.Println("5. 映射的高级操作:")
|
||
|
||
// 映射合并
|
||
fmt.Printf(" 映射合并:\n")
|
||
map1 := map[string]int{"a": 1, "b": 2, "c": 3}
|
||
map2 := map[string]int{"c": 30, "d": 4, "e": 5}
|
||
|
||
fmt.Printf(" map1: %v\n", map1)
|
||
fmt.Printf(" map2: %v\n", map2)
|
||
|
||
// 合并 map2 到 map1
|
||
for key, value := range map2 {
|
||
map1[key] = value
|
||
}
|
||
fmt.Printf(" 合并后: %v\n", map1)
|
||
|
||
// 映射复制
|
||
fmt.Printf(" 映射复制:\n")
|
||
original := map[string]int{"x": 10, "y": 20, "z": 30}
|
||
copied := make(map[string]int)
|
||
|
||
for key, value := range original {
|
||
copied[key] = value
|
||
}
|
||
|
||
fmt.Printf(" 原映射: %v\n", original)
|
||
fmt.Printf(" 复制映射: %v\n", copied)
|
||
|
||
// 修改复制的映射不影响原映射
|
||
copied["x"] = 99
|
||
fmt.Printf(" 修改复制后:\n")
|
||
fmt.Printf(" 原映射: %v\n", original)
|
||
fmt.Printf(" 复制映射: %v\n", copied)
|
||
|
||
// 映射过滤
|
||
fmt.Printf(" 映射过滤:\n")
|
||
allScores := map[string]int{
|
||
"Alice": 95, "Bob": 67, "Charlie": 92,
|
||
"David": 45, "Eve": 89, "Frank": 78,
|
||
}
|
||
|
||
// 过滤出及格的学生
|
||
passing := make(map[string]int)
|
||
for name, score := range allScores {
|
||
if score >= 70 {
|
||
passing[name] = score
|
||
}
|
||
}
|
||
|
||
fmt.Printf(" 所有分数: %v\n", allScores)
|
||
fmt.Printf(" 及格学生: %v\n", passing)
|
||
|
||
// 映射转换
|
||
fmt.Printf(" 映射转换:\n")
|
||
temperatures := map[string]float64{
|
||
"北京": 25.5,
|
||
"上海": 28.3,
|
||
"广州": 32.1,
|
||
}
|
||
|
||
// 摄氏度转华氏度
|
||
fahrenheit := make(map[string]float64)
|
||
for city, celsius := range temperatures {
|
||
fahrenheit[city] = celsius*9/5 + 32
|
||
}
|
||
|
||
fmt.Printf(" 摄氏度: %v\n", temperatures)
|
||
fmt.Printf(" 华氏度: %v\n", fahrenheit)
|
||
|
||
// 反转映射（键值互换）
|
||
fmt.Printf(" 反转映射:\n")
|
||
codeToName := map[int]string{
|
||
1: "Alice",
|
||
2: "Bob",
|
||
3: "Charlie",
|
||
}
|
||
|
||
nameToCode := make(map[string]int)
|
||
for code, name := range codeToName {
|
||
nameToCode[name] = code
|
||
}
|
||
|
||
fmt.Printf(" 代码到姓名: %v\n", codeToName)
|
||
fmt.Printf(" 姓名到代码: %v\n", nameToCode)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstrateMapAsSet 演示映射作为集合使用
|
||
func demonstrateMapAsSet() {
|
||
fmt.Println("6. 映射作为集合使用:")
|
||
|
||
fmt.Printf(" Go 没有内置的集合类型，可以用 map[T]bool 模拟\n")
|
||
|
||
// 创建集合
|
||
fmt.Printf(" 创建集合:\n")
|
||
fruits := make(map[string]bool)
|
||
|
||
// 添加元素
|
||
fruits["apple"] = true
|
||
fruits["banana"] = true
|
||
fruits["cherry"] = true
|
||
|
||
fmt.Printf(" 水果集合: %v\n", getKeys(fruits))
|
||
|
||
// 检查元素是否存在
|
||
fmt.Printf(" 检查元素存在:\n")
|
||
fmt.Printf(" apple 存在: %t\n", fruits["apple"])
|
||
fmt.Printf(" grape 存在: %t\n", fruits["grape"])
|
||
|
||
// 删除元素
|
||
delete(fruits, "banana")
|
||
fmt.Printf(" 删除 banana 后: %v\n", getKeys(fruits))
|
||
|
||
// 集合运算
|
||
fmt.Printf(" 集合运算:\n")
|
||
set1 := map[string]bool{"a": true, "b": true, "c": true}
|
||
set2 := map[string]bool{"b": true, "c": true, "d": true}
|
||
|
||
fmt.Printf(" 集合1: %v\n", getKeys(set1))
|
||
fmt.Printf(" 集合2: %v\n", getKeys(set2))
|
||
|
||
// 并集
|
||
union := make(map[string]bool)
|
||
for key := range set1 {
|
||
union[key] = true
|
||
}
|
||
for key := range set2 {
|
||
union[key] = true
|
||
}
|
||
fmt.Printf(" 并集: %v\n", getKeys(union))
|
||
|
||
// 交集
|
||
intersection := make(map[string]bool)
|
||
for key := range set1 {
|
||
if set2[key] {
|
||
intersection[key] = true
|
||
}
|
||
}
|
||
fmt.Printf(" 交集: %v\n", getKeys(intersection))
|
||
|
||
// 差集 (set1 - set2)
|
||
difference := make(map[string]bool)
|
||
for key := range set1 {
|
||
if !set2[key] {
|
||
difference[key] = true
|
||
}
|
||
}
|
||
fmt.Printf(" 差集(1-2): %v\n", getKeys(difference))
|
||
|
||
// 使用 map[T]struct{} 更节省内存
|
||
fmt.Printf(" 使用 struct{} 作为值更节省内存:\n")
|
||
efficientSet := make(map[string]struct{})
|
||
efficientSet["item1"] = struct{}{}
|
||
efficientSet["item2"] = struct{}{}
|
||
|
||
// 检查存在
|
||
_, exists := efficientSet["item1"]
|
||
fmt.Printf(" item1 存在: %t\n", exists)
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// demonstratePracticalApplications 演示映射的实际应用
|
||
func demonstratePracticalApplications() {
|
||
fmt.Println("7. 映射的实际应用:")
|
||
|
||
// 应用1: 计数器
|
||
fmt.Printf(" 应用1 - 字符频率统计:\n")
|
||
text := "hello world"
|
||
frequency := make(map[rune]int)
|
||
|
||
for _, char := range text {
|
||
if char != ' ' { // 忽略空格
|
||
frequency[char]++
|
||
}
|
||
}
|
||
|
||
fmt.Printf(" 文本: \"%s\"\n", text)
|
||
fmt.Printf(" 字符频率:\n")
|
||
for char, count := range frequency {
|
||
fmt.Printf(" '%c': %d\n", char, count)
|
||
}
|
||
|
||
// 应用2: 缓存系统
|
||
fmt.Printf(" 应用2 - 简单缓存:\n")
|
||
cache := NewCache()
|
||
|
||
// 设置缓存
|
||
cache.Set("user:123", "Alice")
|
||
cache.Set("user:456", "Bob")
|
||
|
||
// 获取缓存
|
||
if value, found := cache.Get("user:123"); found {
|
||
fmt.Printf(" 缓存命中: user:123 = %s\n", value)
|
||
}
|
||
|
||
if value, found := cache.Get("user:789"); found {
|
||
fmt.Printf(" 缓存命中: user:789 = %s\n", value)
|
||
} else {
|
||
fmt.Printf(" 缓存未命中: user:789\n")
|
||
}
|
||
|
||
// 应用3: 配置管理
|
||
fmt.Printf(" 应用3 - 配置管理:\n")
|
||
config := map[string]interface{}{
|
||
"database.host": "localhost",
|
||
"database.port": 5432,
|
||
"database.ssl": true,
|
||
"app.debug": false,
|
||
"app.max_connections": 100,
|
||
}
|
||
|
||
fmt.Printf(" 配置项:\n")
|
||
for key, value := range config {
|
||
fmt.Printf(" %s: %v (%T)\n", key, value, value)
|
||
}
|
||
|
||
// 应用4: 分组统计
|
||
fmt.Printf(" 应用4 - 学生成绩分组:\n")
|
||
students := []struct {
|
||
Name string
|
||
Grade string
|
||
Score int
|
||
}{
|
||
{"Alice", "A", 95},
|
||
{"Bob", "B", 87},
|
||
{"Charlie", "A", 92},
|
||
{"David", "C", 78},
|
||
{"Eve", "B", 89},
|
||
{"Frank", "A", 96},
|
||
}
|
||
|
||
// 按等级分组
|
||
gradeGroups := make(map[string][]string)
|
||
gradeScores := make(map[string][]int)
|
||
|
||
for _, student := range students {
|
||
gradeGroups[student.Grade] = append(gradeGroups[student.Grade], student.Name)
|
||
gradeScores[student.Grade] = append(gradeScores[student.Grade], student.Score)
|
||
}
|
||
|
||
fmt.Printf(" 按等级分组:\n")
|
||
for grade, names := range gradeGroups {
|
||
scores := gradeScores[grade]
|
||
avg := average(scores)
|
||
fmt.Printf(" %s级: %v (平均分: %.1f)\n", grade, names, avg)
|
||
}
|
||
|
||
// 应用5: 索引构建
|
||
fmt.Printf(" 应用5 - 倒排索引:\n")
|
||
documents := map[string]string{
|
||
"doc1": "go programming language",
|
||
"doc2": "python programming tutorial",
|
||
"doc3": "go web development",
|
||
"doc4": "java programming guide",
|
||
}
|
||
|
||
// 构建倒排索引
|
||
index := buildInvertedIndex(documents)
|
||
|
||
fmt.Printf(" 文档:\n")
|
||
for docId, content := range documents {
|
||
fmt.Printf(" %s: %s\n", docId, content)
|
||
}
|
||
|
||
fmt.Printf(" 倒排索引:\n")
|
||
for word, docIds := range index {
|
||
fmt.Printf(" %s: %v\n", word, docIds)
|
||
}
|
||
|
||
// 搜索
|
||
searchWord := "programming"
|
||
if docIds, found := index[searchWord]; found {
|
||
fmt.Printf(" 搜索 '%s': 找到文档 %v\n", searchWord, docIds)
|
||
}
|
||
|
||
fmt.Println()
|
||
}
|
||
|
||
// ========== 辅助函数和类型 ==========
|
||
|
||
// 获取映射的所有键
|
||
func getKeys(m map[string]bool) []string {
|
||
var keys []string
|
||
for key := range m {
|
||
keys = append(keys, key)
|
||
}
|
||
sort.Strings(keys) // 排序以便输出一致
|
||
return keys
|
||
}
|
||
|
||
// 计算平均值
|
||
func average(numbers []int) float64 {
|
||
if len(numbers) == 0 {
|
||
return 0
|
||
}
|
||
|
||
sum := 0
|
||
for _, num := range numbers {
|
||
sum += num
|
||
}
|
||
|
||
return float64(sum) / float64(len(numbers))
|
||
}
|
||
|
||
// 简单缓存实现
|
||
type Cache struct {
|
||
data map[string]string
|
||
}
|
||
|
||
func NewCache() *Cache {
|
||
return &Cache{
|
||
data: make(map[string]string),
|
||
}
|
||
}
|
||
|
||
func (c *Cache) Set(key, value string) {
|
||
c.data[key] = value
|
||
}
|
||
|
||
func (c *Cache) Get(key string) (string, bool) {
|
||
value, exists := c.data[key]
|
||
return value, exists
|
||
}
|
||
|
||
func (c *Cache) Delete(key string) {
|
||
delete(c.data, key)
|
||
}
|
||
|
||
func (c *Cache) Clear() {
|
||
c.data = make(map[string]string)
|
||
}
|
||
|
||
// 构建倒排索引
|
||
func buildInvertedIndex(documents map[string]string) map[string][]string {
|
||
index := make(map[string][]string)
|
||
|
||
for docId, content := range documents {
|
||
words := strings.Fields(content)
|
||
for _, word := range words {
|
||
// 检查是否已经包含该文档
|
||
found := false
|
||
for _, existingDocId := range index[word] {
|
||
if existingDocId == docId {
|
||
found = true
|
||
break
|
||
}
|
||
}
|
||
|
||
if !found {
|
||
index[word] = append(index[word], docId)
|
||
}
|
||
}
|
||
}
|
||
|
||
return index
|
||
}
|
||
|
||
// 需要导入 strings 包
|
||
import "strings"
|
||
|
||
/*
|
||
运行这个程序：
|
||
go run 03-maps.go
|
||
|
||
学习要点：
|
||
1. 映射是键值对的无序集合，键必须是可比较类型
|
||
2. 映射是引用类型，零值是 nil
|
||
3. 映射的长度是动态的，可以增长和缩减
|
||
4. 映射不能直接比较，只能与 nil 比较
|
||
5. 映射的遍历顺序是随机的
|
||
|
||
映射的特性：
|
||
1. 键唯一性：每个键只能对应一个值
|
||
2. 动态大小：可以动态添加和删除键值对
|
||
3. 快速查找：平均 O(1) 时间复杂度
|
||
4. 无序性：不保证遍历顺序
|
||
5. 引用语义：赋值和传参传递引用
|
||
|
||
创建映射的方式：
|
||
1. 字面量：map[KeyType]ValueType{key: value}
|
||
2. make函数：make(map[KeyType]ValueType)
|
||
3. 空字面量：map[KeyType]ValueType{}
|
||
|
||
基本操作：
|
||
1. 添加/更新：m[key] = value
|
||
2. 读取：value := m[key]
|
||
3. 检查存在：value, ok := m[key]
|
||
4. 删除：delete(m, key)
|
||
5. 长度：len(m)
|
||
|
||
可比较的键类型：
|
||
1. 基本类型：bool, 数值类型, string
|
||
2. 指针类型
|
||
3. 数组类型（元素可比较）
|
||
4. 结构体类型（所有字段可比较）
|
||
|
||
不可比较的键类型：
|
||
1. 切片类型
|
||
2. 映射类型
|
||
3. 函数类型
|
||
4. 包含不可比较字段的结构体
|
||
|
||
常见应用场景：
|
||
1. 缓存和查找表
|
||
2. 计数器和统计
|
||
3. 配置管理
|
||
4. 索引构建
|
||
5. 集合操作
|
||
6. 分组和聚合
|
||
|
||
最佳实践：
|
||
1. 检查键是否存在避免零值混淆
|
||
2. 使用 make 创建空映射而不是 nil 映射
|
||
3. 大映射考虑预分配容量
|
||
4. 使用 map[T]struct{} 实现集合节省内存
|
||
5. 注意映射的并发安全问题
|
||
|
||
注意事项：
|
||
1. nil 映射不能写入，只能读取
|
||
2. 映射不是并发安全的
|
||
3. 映射的遍历顺序是随机的
|
||
4. 删除不存在的键是安全操作
|
||
5. 映射的零值是 nil，不是空映射
|
||
*/ |