Go Map：底层结构、扩容、并发安全与 sync.Map

// hmap 是 map 的运行时表示
type hmap struct {
    count     int             // 当前元素个数，len() 直接读这个字段
    flags     uint8           // 状态标志：是否在写入、是否在遍历等
    B         uint8           // 桶数量 = 2^B，例如 B=5 表示 32 个桶
    noverflow uint16          // 溢出桶的近似数量
    hash0     uint32          // 哈希种子，防止哈希碰撞攻击
    buckets   unsafe.Pointer  // 指向当前桶数组
    oldbuckets unsafe.Pointer // 扩容时指向旧桶数组，非扩容时为 nil
    nevacuate  uintptr        // 疏散进度，记录下一个要搬迁的旧桶编号
    extra     *mapextra       // 溢出桶相关的额外信息
}

// bmap 是一个 bucket 的运行时表示
type bmap struct {
    tophash [8]uint8 // 每个槽位的高 8 位哈希值
}

package main

import "fmt"

func main() {
    m := make(map[int]int)                    // 步骤1：B=0，只有 1 个 bucket
    for i := 0; i < 8; i++ { m[i] = i * 10 }  // 步骤2：插入 8 个 KV，填满 bucket
    fmt.Println("8 个元素 len =", len(m))
    m[8] = 80                                 // 步骤3：第 9 个 → 溢出桶（负载因子 9/8=1.125 < 6.5）
    fmt.Println("第 9 个元素 len =", len(m))
}

// makemap 是 make(map[k]v) 和 make(map[k]v, hint) 的底层实现
func makemap(t *maptype, hint int, h *hmap) *hmap {
    if h == nil { h = new(hmap) }                    // 步骤1：分配 hmap 结构体
    h.hash0 = uint32(rand())                         // 步骤2：随机哈希种子，防碰撞攻击
    B := uint8(0)                                    // 步骤3：根据 hint 计算 B
    for overLoadFactor(hint, B) { B++ }              // 找最小 B 使得 hint/2^B <= 6.5
    h.B = B
    if h.B > 0 {                                     // 步骤4：分配 buckets 数组
        h.buckets, _ = makeBucketArray(t, h.B, nil)  // 可能预分配溢出桶池
    }
    return h
}

package main

import "fmt"

func main() {
    // 步骤1：字面量初始化，编译器统计元素数量(5)作为 hint 传给 makemap 预分配
    m := map[string]int{"Go": 1, "Python": 2, "Rust": 3, "C": 4, "Java": 5}
    fmt.Println(len(m)) // 5
}

package main

import "fmt"

func main() {
    var m map[string]int                       // 步骤1：声明 nil map（底层 hmap 为 nil）
    fmt.Println(m["Go"])                       // 步骤2：读——安全，返回零值 0
    v, ok := m["Go"]; fmt.Println(v, ok)       // 步骤3：判断存在——也安全，0 false
    // m["Go"] = 1                             // 步骤4：写——panic: assignment to entry in nil map
}

package main

import (
    "fmt"
    "time"
)

func main() {
    const N = 100000
    // 步骤1：不预分配——可能多次扩容
    start := time.Now()
    m1 := make(map[int]int)
    for i := 0; i < N; i++ { m1[i] = i }
    fmt.Println("无预分配:", time.Since(start))
    // 步骤2：预分配——一次到位，不扩容
    start = time.Now()
    m2 := make(map[int]int, N)
    for i := 0; i < N; i++ { m2[i] = i }
    fmt.Println("预分配:", time.Since(start)) // 通常快 20%-40%
}

func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
    // 步骤1：nil map 或空 map 直接返回零值
    if h == nil || h.count == 0 { return unsafe.Pointer(&zeroVal[0]) }
    // 步骤2：并发检测——有人在写则 fatal error
    if h.flags&hashWriting != 0 { fatal("concurrent map read and map write") }
    // 步骤3：计算哈希值
    hash := t.hasher(key, uintptr(h.hash0))
    // 步骤4：取低 B 位定位 bucket
    b := (*bmap)(add(h.buckets, (hash&bucketMask(h.B))*uintptr(t.bucketsize)))
    // 步骤5：扩容期间可能需要去 oldbuckets 找（旧桶未搬迁完时）
    if c := h.oldbuckets; c != nil {
        oldb := (*bmap)(add(c, (hash&bucketMask(h.B-1))*uintptr(t.bucketsize)))
        if !evacuated(oldb) { b = oldb }
    }
    // 步骤6：取高 8 位作为 tophash 快速筛选
    top := tophash(hash)
    // 步骤7：遍历 bucket 及 overflow 链，先比 tophash 再精确比较 key
    for ; b != nil; b = b.overflow(t) {
        for i := uintptr(0); i < bucketCnt; i++ {
            if b.tophash[i] != top { continue }           // 步骤7a：tophash 不匹配，跳过
            k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
            if t.key.equal(key, k) {                       // 步骤7b：tophash 匹配，精确比较 key
                v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
                return v                                   // 步骤7c：key 相等，返回 value 地址
            }
        }
    }
    return unsafe.Pointer(&zeroVal[0]) // 步骤8：没找到，返回零值
}

package main

import "fmt"

func main() {
    m := make(map[string]int)

    // 步骤1：插入新 key——调用 mapassign
    m["Go"] = 1
    // 底层：hash("Go") → 定位 bucket → 遍历找空位 → 写入 tophash + key + value

    // 步骤2：更新已有 key——也是调用 mapassign
    m["Go"] = 2
    // 底层：找到 "Go" 对应的槽位 → 覆盖 value

    // 步骤3：插入前检查是否需要扩容
    // 如果 count+1 > 6.5 * 2^B → 触发翻倍扩容
    // 如果 overflow 桶过多 → 触发等量扩容

    fmt.Println(m["Go"]) // 2
}

package main

func main() {
    // 步骤1：合法的 key 类型
    m1 := make(map[string]int)        // string 可以
    m2 := make(map[int]string)        // int 可以
    m3 := make(map[[2]int]string)     // 数组可以（定长，可比较）
    // 步骤2：非法的 key 类型——编译错误
    // m4 := make(map[[]int]string)           // slice 不行
    // m5 := make(map[map[int]int]string)     // map 不行
    // m6 := make(map[func()]string)          // func 不行
    // 步骤3：struct 作为 key——所有字段可比较就行
    type Point struct{ X, Y int }
    m7 := make(map[Point]string); m7[Point{1, 2}] = "A"
    _, _, _, _ = m1, m2, m3, m7
}

package main

import "fmt"

func main() {
    m := map[string]int{"Go": 1, "Python": 2, "Rust": 3, "C": 4, "Java": 5}
    // 步骤1：第一次遍历
    fmt.Println("第一次:")
    for k, v := range m { fmt.Printf("  %s: %d\n", k, v) }
    // 步骤2：第二次遍历——顺序大概率不同
    fmt.Println("第二次:")
    for k, v := range m { fmt.Printf("  %s: %d\n", k, v) }
    // 原因：mapiterinit 随机选择起始 bucket 和起始槽位
}

// 步骤：len(map) 直接返回 h.count，没有任何计算开销
// 对比：len(slice) 也是 O(1)，读 slice 的 len 字段
// 但 len(string) 遍历 UTF-8 字符时是 O(n)
fmt.Println(len(m)) // 底层：return h.count

package main

import "fmt"

func main() {
    m := map[string]int{"Go": 1, "Python": 2, "Rust": 3}
    delete(m, "Go")               // 步骤1：删除元素
    fmt.Println(m)                 // map[Python:2 Rust:3]
    delete(m, "NotExist")          // 步骤2：删不存在的 key——不报错
    fmt.Println(len(m))            // 2
    // 步骤3：delete 不缩容！map 只会变大不会变小
}

// 负载因子 = count / 2^B
// Go 的阈值是 6.5，定义在 runtime/map.go
const loadFactorNum = 13
const loadFactorDen = 2  // 13/2 = 6.5

// overLoadFactor 判断给定 hint 和 B 是否超载
func overLoadFactor(count int, B uint8) bool {
    return count > bucketCnt && uintptr(count) > loadFactorNum*(bucketShift(B)/loadFactorDen)
    // 即 count > 6.5 * 2^B
}

package main

import "fmt"

func main() {
    // 步骤1：翻倍扩容——初始 B=0（1个桶），负载因子 > 6.5 时 B+1
    m1 := make(map[int]int)
    for i := 0; i < 100; i++ {
        m1[i] = i
        // i=6: count=7, 7/1=7 > 6.5 → B 变 1（2桶）
        // i=13: count=14, 14/2=7 > 6.5 → B 变 2（4桶）
    }
    fmt.Println("翻倍扩容后 len =", len(m1))

    // 步骤2：等量扩容——大量删除后 overflow 碎片过多
    m2 := make(map[int]int)
    for i := 0; i < 1000; i++ { m2[i] = i }
    for i := 0; i < 900; i++ { delete(m2, i) }
    // count=100 但 overflow 链可能很长 → 再插入时触发等量扩容
    fmt.Println("等量扩容后 len =", len(m2))
}

// mapassign 中的扩容检查逻辑（简化版）
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
    // ...
    // 步骤1：如果正在扩容，先搬迁一部分
    if h.growing() {
        growWork(t, h, bucket)
    }
    // 步骤2：检查是否需要触发扩容
    if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
        hashGrow(t, h, nil)
    }
    // 步骤3：在（可能正在扩容的）bucket 中找到位置写入
    // ...
}

// growWork 每次最多搬迁 2 个 bucket
func growWork(t *maptype, h *hmap, bucket uintptr) {
    // 步骤1：搬迁当前操作涉及的那个旧桶
    evacuate(t, h, bucket&h.oldbucketmask())

    // 步骤2：额外搬迁一个旧桶（nevacuate 指向的）
    evacuate(t, h, h.nevacuate)
}

package main

import "fmt"

func main() {
    m := make(map[int]int)
    for i := 0; i < 10000; i++ { m[i] = i } // 步骤1：大量插入，触发扩容
    // 扩容期间读写都安全：mapaccess/mapassign/mapdelete 会检查 oldbuckets
    // 如果非 nil 且旧桶未搬迁完，会去旧桶查找/写入/删除
    fmt.Println("m[42] =", m[42]) // 步骤2：扩容期间读取仍然安全
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    m := make(map[int]int)
    var wg sync.WaitGroup
    // 步骤1：一个 goroutine 不断写
    wg.Add(1)
    go func() { defer wg.Done(); for i := 0; i < 100000; i++ { m[i] = i } }()
    // 步骤2：另一个 goroutine 不断读
    wg.Add(1)
    go func() { defer wg.Done(); for i := 0; i < 100000; i++ { _ = m[i] } }()
    wg.Wait()
    // fatal error: concurrent map read and map write
    // 注意：这不是 panic，无法用 recover 捕获！
    fmt.Println("完成")
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    m := map[int]int{1: 10, 2: 20, 3: 30}
    var wg sync.WaitGroup
    // 步骤1：多个 goroutine 只读——安全，不触发 fatal error
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() { defer wg.Done(); _ = m[1]; _ = m[2]; _ = m[3] }()
    }
    wg.Wait()
    fmt.Println("并发读完成，无错误")
    // 步骤2：只要有一个 goroutine 在写，其他读也会 fatal error
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 步骤1：map 并发读写——fatal error，程序崩溃
    // m := make(map[int]int)
    // go func() { m[1] = 1 }(); go func() { _ = m[1] }()
    // → fatal error: concurrent map read and map write

    // 步骤2：slice 并发写各索引——不崩溃
    s := make([]int, 10)
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) { defer wg.Done(); s[idx] = idx }(i)
    }
    wg.Wait()
    fmt.Println("slice 并发写:", s)

    // 步骤3：slice 并发 append——数据可能丢失，不崩溃
    s2 := make([]int, 0)
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(val int) { defer wg.Done(); s2 = append(s2, val) }(i)
    }
    wg.Wait()
    fmt.Println("slice 并发 append len:", len(s2)) // 可能 < 10
}

// sync.Map 的核心结构（简化版）
type Map struct {
    mu     Mutex              // 保护 dirty 的互斥锁
    read   atomic.Value       // 存 readOnly 结构，原子读写
    dirty  map[any]*entry     // 脏 map，包含 read 中没有的新 key
    misses int                // dirty 未命中计数
}
type readOnly struct {
    m       map[any]*entry    // 只读 map
    amended bool              // dirty 中是否有 read 中没有的 key
}
type entry struct {
    p unsafe.Pointer // 三种状态：nil(已删除) / expunged(已删除且 dirty 无此 entry) / 正常指针
}

// sync.Map.Load 的核心逻辑（简化版）
func (m *Map) Load(key any) (value any, ok bool) {
    read := m.loadReadOnly()
    e, ok := read.m[key]              // 步骤1：无锁原子读 read
    if !ok && read.amended {          // read 未命中且 dirty 可能有新数据
        m.mu.Lock()                   // 步骤2：加锁
        read = m.loadReadOnly()       // 步骤3：双重检查 read（防加锁期间被提升）
        e, ok = read.m[key]
        if !ok && read.amended {
            e, ok = m.dirty[key]      // 步骤4：读 dirty
            m.misses++                // 步骤5：misses 计数 +1
            if m.misses > len(m.dirty) { // 步骤6：misses 超阈值 → 提升 dirty 为 read
                m.dirtyLocked()
                m.read.Store(readOnly{m: m.dirty})
                m.dirty = nil; m.misses = 0
            }
        }
        m.mu.Unlock()
    }
    if !ok { return nil, false }
    return e.load()                   // 步骤7：原子读取 entry 值
}

// sync.Map.Store 的核心逻辑（简化版）
func (m *Map) Store(key, value any) {
    read := m.loadReadOnly()
    if e, ok := read.m[key]; ok && e.tryStore(&value) {
        return                            // 步骤1：无锁 CAS 更新 read 中已有 key，成功则返回
    }
    m.mu.Lock()                           // 步骤2：CAS 失败 → 加锁
    read = m.loadReadOnly()
    if e, ok := read.m[key]; ok {         // 步骤3：key 在 read 中
        if e.unexpungeLocked() { m.dirty[key] = e } // 3a：expunged → 恢复并加入 dirty
        e.storeLocked(&value)             // 3b：更新 value
    } else if e, ok := m.dirty[key]; ok { // 步骤4：key 在 dirty 中 → 直接更新
        e.storeLocked(&value)
    } else {                              // 步骤5：key 不存在 → 写入 dirty
        if !read.amended { m.dirtyLocked(); m.read.Store(readOnly{m: read.m, amended: true}) } // 5a：dirty 为 nil 时从 read 重建
        m.dirty[key] = newEntry(value)    // 5b：写入 dirty
    }
    m.mu.Unlock()
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    m.Store("Go", 1)                              // 步骤1：写入
    v, ok := m.Load("Go")                          // 步骤2：读取
    fmt.Println("Load Go:", v, ok)                 // 1 true
    old, loaded := m.LoadOrStore("Go", 100)        // 步骤3：不存在则存入，存在则返回已有值
    fmt.Println("LoadOrStore Go:", old, loaded)    // 1 true
    m.Range(func(k, v any) bool { fmt.Println(k, v); return true }) // 步骤4：遍历
    m.Delete("Go")                                 // 步骤5：删除
    v, ok = m.LoadAndDelete("Python")              // 步骤6：删除并返回旧值
    fmt.Println("LoadAndDelete:", v, ok)
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    const numReaders, numWriters, numOps = 100, 10, 100000

    // 步骤1：测试 map + sync.RWMutex
    var mu sync.RWMutex
    m1 := make(map[int]int)
    for i := 0; i < 1000; i++ { m1[i] = i }
    var wg sync.WaitGroup
    start := time.Now()
    for i := 0; i < numReaders; i++ {
        wg.Add(1)
        go func() { defer wg.Done(); for j := 0; j < numOps; j++ { mu.RLock(); _ = m1[j%1000]; mu.RUnlock() } }()
    }
    for i := 0; i < numWriters; i++ {
        wg.Add(1)
        go func() { defer wg.Done(); for j := 0; j < numOps; j++ { mu.Lock(); m1[j%1000] = j; mu.Unlock() } }()
    }
    wg.Wait()
    fmt.Printf("map+RWMutex: %v\n", time.Since(start))

    // 步骤2：测试 sync.Map
    var m2 sync.Map
    for i := 0; i < 1000; i++ { m2.Store(i, i) }
    start = time.Now()
    for i := 0; i < numReaders; i++ {
        wg.Add(1)
        go func() { defer wg.Done(); for j := 0; j < numOps; j++ { _, _ = m2.Load(j % 1000) } }()
    }
    for i := 0; i < numWriters; i++ {
        wg.Add(1)
        go func() { defer wg.Done(); for j := 0; j < numOps; j++ { m2.Store(j%1000, j) } }()
    }
    wg.Wait()
    fmt.Printf("sync.Map: %v\n", time.Since(start))
}

// 场景1：读多写少 + key 稳定 → sync.Map（配置缓存、路由表）
var configCache sync.Map

// 场景2：读写均衡 → map + sync.RWMutex
type SafeMap struct {
    mu sync.RWMutex
    m  map[string]int
}
func (s *SafeMap) Get(key string) (int, bool) { s.mu.RLock(); defer s.mu.RUnlock(); v, ok := s.m[key]; return v, ok }
func (s *SafeMap) Set(key string, val int)     { s.mu.Lock(); defer s.mu.Unlock(); s.m[key] = val }

// 场景3：写多读少 → map + sync.Mutex（RWMutex 写多场景反而比 Mutex 慢）

package main

import "fmt"

func main() {
    m := map[string]int{"Go": 1, "Python": 2}
    // 步骤1：&m["Go"] 编译错误：cannot take the address of m["Go"]
    // 因为 map 扩容时 value 地址会变，取到的指针会变野指针
    // 步骤2：slice 元素可以取地址（slice 底层是连续数组，不会搬迁）
    s := []int{10, 20, 30}
    p := &s[0]
    fmt.Println(*p) // 10
    _ = m
}

package main

import "fmt"

func modify(m map[string]int) {
    m["Go"] = 100                       // 步骤1：修改已有 key——影响原 map
    m["New"] = 999                      // 步骤2：插入新 key——也影响原 map
    // m = make(map[string]int)         // 步骤3：重新赋值——不影响原 map（只改局部变量指向）
}

func main() {
    m := map[string]int{"Go": 1, "Python": 2}
    modify(m)                           // 步骤4：传参（传的是 hmap 指针的副本）
    fmt.Println(m["Go"], m["New"], m["Python"]) // 100 999 2
}

package main

import "fmt"

func main() {
    // 步骤1：不预分配——多次扩容
    m1 := make(map[int]int)
    for i := 0; i < 1000000; i++ { m1[i] = i }

    // 步骤2：预分配——一次到位，B≈17（2^17*6.5≈85万 >= 100万）
    m2 := make(map[int]int, 1000000)
    for i := 0; i < 1000000; i++ { m2[i] = i }
    fmt.Println("len 相同:", len(m1) == len(m2))
}

// 步骤3：用 benchmark 对比（BenchmarkWithHint 通常快 30%-50%）
func BenchmarkNoHint(b *testing.B) {
    for i := 0; i < b.N; i++ {
        m := make(map[int]int)
        for j := 0; j < 10000; j++ { m[j] = j }
    }
}
func BenchmarkWithHint(b *testing.B) {
    for i := 0; i < b.N; i++ {
        m := make(map[int]int, 10000)
        for j := 0; j < 10000; j++ { m[j] = j }
    }
}

package main

import "fmt"

type student struct {
	Name string
	Age  int
}

func pase_student() map[string]*student {
	m := make(map[string]*student)
	stus := []student{
		{Name: "zhou", Age: 24},
		{Name: "li", Age: 23},
		{Name: "wang", Age: 22},
	}
	for _, stu := range stus {
		// 步骤1：stu 是"复用"的循环变量，每一轮都指向同一块内存地址
		// 把 &stu 存进 map，三个 key 拿到的是同一个地址
		m[stu.Name] = &stu
	}
	return m
}

func main() {
	m := pase_student()
	for k, v := range m {
		// 步骤2：三个 key 全指向同一个 stu，最终都打印最后一轮的值（wang 22）
		fmt.Println(k, "->", v.Name, v.Age)
	}
}

package main

import "fmt"

func main() {
	x := map[string]string{"one": "a", "two": "", "three": "c"}

	// 步骤1：错误写法——two 存在但值是空串，会被误判为"不存在"
	if v := x["two"]; v == "" {
		fmt.Println("no entry") // 误报！two 其实存在
	}

	// 步骤2：正确写法——用逗号 ok 判断 key 是否真的存在
	if _, ok := x["two"]; !ok {
		fmt.Println("no entry")
	} else {
		fmt.Println("two exists, value is empty string")
	}
}

package main

import (
	"fmt"
	"sync"
)

func main() {
	var m sync.Map

	// 细节一：LoadOrStore + Delete 之后，Len() 返回 0（不是 1、不是 panic）
	m.LoadOrStore("a", 1)
	m.Delete("a")
	fmt.Println(m.Len()) // 0

	// 细节二：Load 返回 (interface{}, bool)，不能直接用索引语法
	m.Store("address", map[string]string{"province": "GD", "city": "SZ"})
	v, _ := m.Load("address")
	// fmt.Println(v["province"]) // 编译错误：interface{} does not support indexing
	// 正确：先类型断言再使用
	if mp, ok := v.(map[string]string); ok {
		fmt.Println(mp["province"])
	}
}

package main

import "fmt"

func main() {
	m := make(map[string]int, 2) // hint=2 只是预分配建议，不是容量上限
	// fmt.Println(cap(m))        // 编译错误：invalid argument m (type map[string]int) for cap
	fmt.Println(len(m)) // 0，len 永远 O(1) 读 hmap.count
}

func mapiterinit(t *maptype, h *hmap, it *hiter) {
    // 步骤1：随机选起始 bucket，避免每次都从 0 号桶开始
    r := uintptr(fastrand())
    it.startBucket = r & bucketMask(h.B)        // 随机 bucket 索引
    // 步骤2：随机选桶内起始偏移（0~7），在 bucket 内也打乱起点
    it.offset = uint8(r >> (sys.PtrSize*8 - 3)) // 取更高位的几位，得到 0..7
    // 步骤3：再加一个随机"跳步"seed，让扫描顺序也带随机性
    // ... 之后从 (startBucket, offset) 开始按固定步长绕圈扫描
}

package main

import (
	"fmt"
	"sort"
)

func main() {
	m := map[string]int{"banana": 3, "apple": 1, "cherry": 2, "date": 4}

	// 步骤1：收集所有 key 到 slice
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}

	// 步骤2：对 key 排序（升序）
	sort.Strings(keys)

	// 步骤3：按排序后的 key 顺序取值 —— 这才是稳定有序的遍历
	for _, k := range keys {
		fmt.Printf("%s = %d\n", k, m[k])
	}
	// 输出：apple=1 banana=3 cherry=2 date=4（永远按字母序）
}

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	m := map[string]Point{"a": {X: 1, Y: 2}}

	// 步骤1：取出的是 Point 的副本（值拷贝）
	p := m["a"]
	p.X = 100 // 步骤2：只改了副本

	fmt.Println(m["a"].X) // 输出 1 —— 原 map 没变！
	// 步骤3：要生效必须写回去
	m["a"] = p
	fmt.Println(m["a"].X) // 输出 100
}

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	m := map[string]*Point{"a": {X: 1, Y: 2}}

	// 步骤1：取出的是指针，指向 map 里存的那块内存
	p := m["a"]
	p.X = 100 // 步骤2：通过指针修改 —— 原 map 也变了！

	fmt.Println(m["a"].X) // 输出 100 —— 无需重新赋值
}

m := map[string]Point{"a": {X: 1, Y: 2}}
// m["a"].X = 100 // 编译错误：cannot assign to struct field m["a"].X in map

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	// 步骤1：三种常见"占位"类型比较
	var b bool
	var i int
	var s struct{}
	fmt.Println("bool 大小:", unsafe.Sizeof(b))     // 1 字节
	fmt.Println("int 大小:", unsafe.Sizeof(i))      // 8 字节
	fmt.Println("struct{} 大小:", unsafe.Sizeof(s)) // 0 字节！

	// 步骤2：100 万元素的集合，value 用 struct{} 比 bool 省下约 1MB
	set := make(map[string]struct{})
	set["alice"] = struct{}{} // 只关心 key 是否存在
	_, ok := set["alice"]
	fmt.Println("alice 在集合中?", ok) // true
}

package main

import "fmt"

// StringSet 基于 map[string]struct{} 的字符串集合
type StringSet map[string]struct{}

// NewStringSet 从可变参数创建集合（自动去重）
func NewStringSet(items ...string) StringSet {
	s := make(StringSet, len(items))
	for _, it := range items {
		s.Add(it) // 步骤1：逐个加入，重复的 key 自动覆盖
	}
	return s
}

// Add 增加元素
func (s StringSet) Add(x string) {
	s[x] = struct{}{} // 步骤2：set value 为空的 struct
}

// Has 判断元素是否存在（必须用 ok 形式，不能用 value 判空）
func (s StringSet) Has(x string) bool {
	_, ok := s[x]
	return ok // 步骤3：struct{} 的值恒为空，只能靠 ok 判断 key 是否存在
}

// Delete 删除元素
func (s StringSet) Delete(x string) {
	delete(s, x) // 步骤4：delete 不存在的 key 也不报错
}

// Union 并集：A ∪ B，返回新集合
func (s StringSet) Union(other StringSet) StringSet {
	res := NewStringSet()
	for k := range s { // 步骤5：把自己所有元素加入结果
		res.Add(k)
	}
	for k := range other { // 步骤6：再合并对方所有元素，重复自动去重
		res.Add(k)
	}
	return res
}

// Intersect 交集：A ∩ B，两边都有的才保留
func (s StringSet) Intersect(other StringSet) StringSet {
	res := NewStringSet()
	for k := range s {
		if other.Has(k) { // 步骤7：只保留对方也有的
			res.Add(k)
		}
	}
	return res
}

// Difference 差集：A - B，在 A 但不在 B 的
func (s StringSet) Difference(other StringSet) StringSet {
	res := NewStringSet()
	for k := range s {
		if !other.Has(k) { // 步骤8：只保留对方没有的
			res.Add(k)
		}
	}
	return res
}

func main() {
	a := NewStringSet("go", "rust", "java")
	b := NewStringSet("go", "python", "java")

	fmt.Println("并集:", a.Union(b))         // 含 go rust java python
	fmt.Println("交集:", a.Intersect(b))      // 含 go java
	fmt.Println("差集 a-b:", a.Difference(b)) // 含 rust
}