Map

// 声明（nil map，不能直接使用）
var m1 map[string]int

// 使用make创建（推荐！）
m2 := make(map[string]int)

// 字面量创建
m3 := map[string]int{
    "apple":  5,
    "banana": 3,
    "orange": 8,
}

// 空map
m4 := map[string]int{}

m := make(map[string]int)

// 添加/修改
m["apple"] = 5
m["banana"] = 3

// 读取
fmt.Println(m["apple"])  // 5

// 读取不存在的key，返回零值
fmt.Println(m["grape"])  // 0

// 检查key是否存在
value, exists := m["apple"]
if exists {
    fmt.Println("apple =", value)
}

// 简写（常用！）
if value, ok := m["apple"]; ok {
    fmt.Println("apple =", value)
}

// 删除
delete(m, "apple")

// 获取长度
fmt.Println(len(m))  // 1

m := map[string]int{
    "apple":  5,
    "banana": 3,
    "orange": 8,
}

// 遍历key-value
for key, value := range m {
    fmt.Printf("%s: %d\n", key, value)
}

// 只遍历key
for key := range m {
    fmt.Println(key)
}

// 只遍历value
for _, value := range m {
    fmt.Println(value)
}

m1 := map[string]int{"a": 1, "b": 2}
m2 := m1  // 只复制了引用！

m2["a"] = 100
fmt.Println(m1["a"])  // 100（m1也变了！）

// ✅ 可以作为key
map[string]int     // 字符串
map[int]string     // 整数
map[bool]string    // 布尔
map[float64]int    // 浮点数（不推荐）

// ❌ 不能作为key
map[[]int]string   // 切片不行
map[map[string]int]string  // map不行

func countChars(s string) map[rune]int {
    counts := make(map[rune]int)
    for _, char := range s {
        counts[char]++
    }
    return counts
}

result := countChars("hello world")
for char, count := range result {
    fmt.Printf("%c: %d\n", char, count)
}

// 用map[T]bool实现Set
set := make(map[string]bool)

// 添加元素
set["apple"] = true
set["banana"] = true

// 检查元素是否存在
if set["apple"] {
    fmt.Println("apple在集合中")
}

// 删除元素
delete(set, "apple")

// 更省内存的方式：map[T]struct{}
set2 := make(map[string]struct{})
set2["apple"] = struct{}{}

if _, exists := set2["apple"]; exists {
    fmt.Println("apple在集合中")
}

type Person struct {
    Name string
    City string
}

people := []Person{
    {"张三", "北京"},
    {"李四", "上海"},
    {"王五", "北京"},
    {"赵六", "上海"},
    {"钱七", "深圳"},
}

// 按城市分组
byCity := make(map[string][]Person)
for _, p := range people {
    byCity[p.City] = append(byCity[p.City], p)
}

for city, persons := range byCity {
    fmt.Printf("%s: %d人\n", city, len(persons))
    for _, p := range persons {
        fmt.Printf("  - %s\n", p.Name)
    }
}

// 带缓存的斐波那契
var cache = make(map[int]int)

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    
    // 检查缓存
    if v, ok := cache[n]; ok {
        return v
    }
    
    // 计算并缓存
    result := fibonacci(n-1) + fibonacci(n-2)
    cache[n] = result
    return result
}

// 二维map
students := map[string]map[string]int{
    "张三": {
        "语文": 85,
        "数学": 92,
        "英语": 78,
    },
    "李四": {
        "语文": 90,
        "数学": 88,
        "英语": 95,
    },
}

// 访问
fmt.Println(students["张三"]["数学"])  // 92

// 添加新学生（需要先初始化内层map）
students["王五"] = make(map[string]int)
students["王五"]["语文"] = 80
// 或者
students["赵六"] = map[string]int{
    "语文": 75,
    "数学": 82,
}

// ❌ 危险！并发读写
m := make(map[string]int)
go func() { m["a"] = 1 }()
go func() { _ = m["a"] }()

// ✅ 使用 sync.Map（Go 1.9+）
var sm sync.Map

sm.Store("key", "value")
value, ok := sm.Load("key")
sm.Delete("key")
sm.Range(func(key, value interface{}) bool {
    fmt.Printf("%v: %v\n", key, value)
    return true  // 继续遍历
})

// ✅ 或使用互斥锁
var mu sync.Mutex
m := make(map[string]int)

mu.Lock()
m["key"] = 1
mu.Unlock()

package main

import (
    "fmt"
    "sort"
    "strings"
)

func main() {
    text := `Go is an open source programming language 
    that makes it easy to build simple reliable and efficient software
    Go is expressive concise clean and efficient`
    
    // 统计词频
    words := strings.Fields(strings.ToLower(text))
    freq := make(map[string]int)
    for _, word := range words {
        freq[word]++
    }
    
    // 按频率排序
    type wordCount struct {
        word  string
        count int
    }
    
    var wcs []wordCount
    for w, c := range freq {
        wcs = append(wcs, wordCount{w, c})
    }
    
    sort.Slice(wcs, func(i, j int) bool {
        return wcs[i].count > wcs[j].count
    })
    
    // 打印Top 10
    fmt.Println("词频统计 Top 10:")
    for i, wc := range wcs {
        if i >= 10 {
            break
        }
        fmt.Printf("%2d. %-15s %d次\n", i+1, wc.word, wc.count)
    }
}

package main

import "fmt"

type Product struct {
    Name  string
    Price float64
}

type Cart struct {
    items map[string]int  // 商品名 -> 数量
    products map[string]Product
}

func NewCart() *Cart {
    return &Cart{
        items:    make(map[string]int),
        products: make(map[string]Product),
    }
}

func (c *Cart) Add(p Product, qty int) {
    c.products[p.Name] = p
    c.items[p.Name] += qty
}

func (c *Cart) Remove(name string) {
    delete(c.items, name)
}

func (c *Cart) Total() float64 {
    total := 0.0
    for name, qty := range c.items {
        total += c.products[name].Price * float64(qty)
    }
    return total
}

func (c *Cart) Show() {
    fmt.Println("购物车清单:")
    fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
    for name, qty := range c.items {
        p := c.products[name]
        subtotal := p.Price * float64(qty)
        fmt.Printf("%-10s ¥%.2f × %d = ¥%.2f\n", name, p.Price, qty, subtotal)
    }
    fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
    fmt.Printf("总计: ¥%.2f\n", c.Total())
}

func main() {
    cart := NewCart()
    
    cart.Add(Product{"苹果", 5.5}, 3)
    cart.Add(Product{"香蕉", 3.0}, 2)
    cart.Add(Product{"橙子", 4.5}, 5)
    
    cart.Show()
}