数组、切片与 map：最常用的三种容器

一、学习目标

二、知识讲解

7.1 数组：定长值类型

数组（Array）是 Go 语言中最基础的数据结构，由相同类型的元素组成的连续内存块。

1. 是什么：数组的长度是类型的一部分。[5]int 和 [10]int 是两种完全不同的类型。数组在声明时必须指定长度，且长度不可改变。
2. 为什么：Go 语言选择固定长度数组是为了在编译期确定内存大小，从而获得极高的访问效率，并避免动态分配带来的开销。
3. 怎么用： go var a [5]int // 声明并初始化为零值 [0 0 0 0 0] b := [3]int{1, 2, 3} c := [...]int{1, 2, 3} // 编译器自动推断长度为 3 注意：数组是值类型。当数组作为函数参数传递时，会复制整个数组的内容。在 64 位平台上，传递一个长度为 N 的数组，内存开销为 $N \times \text{sizeof(Element)}$。

7.2 切片：动态数组与引用语义

切片（Slice）是对数组底层实现的抽象，提供了动态大小的视图。

1. 是什么：切片本身是一个数据结构（Slice Header），包含三个字段： - Pointer：指向底层数组中切片起始元素的指针。 - Len：切片中元素的数量。 - Cap：切片底层数组的容量，即从起始位置到数组末尾的元素数量。

切片不是引用类型，它是值类型（传递时复制 Header，即 24 字节：指针 8 + len 8 + cap 8），但它与兄弟切片共享同一底层数组。

2. 为什么：为了兼顾静态数组的性能和动态数组的灵活性。通过共享底层数组，切片操作（如截取）可以在 $O(1)$ 时间内完成，无需复制数据。

3. 怎么用： - 创建： go s := make([]int, 3, 5) // len=3, cap=5, 底层数组长度为 5 s2 := []int{1, 2, 3} // len=3, cap=3 - 切片表达式：s[low:high:max]

   • s[low:high]：截取从 low 到 high-1 的元素。
   • s[low:high:max]：除了截取元素，还限制新切片的最大容量为 max - low。这常用于防止数据泄露或复用内存。
   • 遍历：使用 for range。

7.3 append 与扩容机制

append 是切片最常用的操作，用于向切片末尾添加元素。

1. 扩容阈值与策略（Go 1.18+）： 当切片容量不足时，append 会分配新的底层数组并复制数据。扩容策略如下： - 当 oldcap < 256 时，新容量约为旧容量的 2 倍（约翻倍）。 - 当 oldcap >= 256 时，新容量按公式 newcap += (newcap + 3*256)/4 增长（约 1.25 倍），最后向上取整到内存规格（size class）。 - 工程实践：不要依赖具体的增长倍数。如果已知切片大致大小，应使用 make([]T, 0, n) 预分配容量，避免频繁扩容带来的内存分配和拷贝开销。

2. 共享底层数组的陷阱： 如果切片容量充足，append 不会触发扩容，而是直接写入底层数组。如果多个切片共享同一底层数组，一个切片的修改会影响其他切片。

7.4 map：哈希表

Map 是 Go 语言内置的哈希表实现，用于键值对存储。

1. 是什么：map[K]V，其中 K 必须是支持 == 和 != 运算的类型（如 int, string, struct 等，不支持 slice, map, function）。
2. 遍历无序性：for range 遍历 map 时，键值对的顺序是随机的。每次运行顺序可能不同。
3. 删除操作： - delete(map, key)：删除指定键。 - 规范语义：在 for range 遍历过程中删除元素是合法的。规范规定：若未迭代到的条目在迭代中被删除，则该条目不会再被产出。 - 新增条目：在遍历过程中新增的条目，是否会被产出是未定义的（可能产出，也可能跳过），因此不建议在遍历中新增。 - 并发安全：原生 map 不是并发安全的。并发读写同一 map 会触发 fatal error: concurrent map reads and map writes 或 concurrent map writes，这是不可 recover 的致命错误。

三、示例代码

示例 1：切片扩容与共享底层数组陷阱

本示例演示 append 触发扩容时底层数组分离，以及容量充足时共享底层数组导致的副作用。

package main

import "fmt"

func main() {
    // 场景 1：容量不足，触发扩容，底层数组分离
    fmt.Println("=== 场景 1：扩容导致底层数组分离 ===")
    s1 := []int{1, 2, 3}
    fmt.Printf("s1: %v, cap: %d\n", s1, cap(s1))

    // 此时 s1 cap=3，append 需要扩容
    s2 := append(s1, 4)
    fmt.Printf("s1: %v, cap: %d\n", s1, cap(s1))
    fmt.Printf("s2: %v, cap: %d\n", s2, cap(s2))
    fmt.Println("s1 和 s2 底层数组已分离，互不影响。")
    fmt.Println()

    // 场景 2：容量充足，直接写入共享数组，影响原切片
    fmt.Println("=== 场景 2：容量充足，共享底层数组 ===")
    // 创建一个容量富余的切片
    s3 := make([]int, 2, 5) // len=2, cap=5
    s3[0] = 10
    s3[1] = 20

    // 创建一个基于 s3 的切片 s4，指向 s3 的第二个元素
    s4 := s3[1:2] // len=1, cap=4, 指向 s3[1]

    fmt.Printf("s3: %v\n", s3)
    fmt.Printf("s4: %v\n", s4)

    // 向 s4 追加元素。因为 s4 的 cap 充足（4 > 1），不会扩容，
    // 直接写入 s3 的底层数组中 s3[2] 的位置
    s4 = append(s4, 99)

    fmt.Printf("s3: %v\n", s3) // s3 被修改！
    fmt.Printf("s4: %v\n", s4)
    fmt.Println("注意：s3[2] 被 s4 的 append 修改了，因为它们共享底层数组。")
}

运行结果（预期输出）：

=== 场景 1：扩容导致底层数组分离 ===
s1: [1 2 3], cap: 3
s1: [1 2 3], cap: 3
s2: [1 2 3 4], cap: 6
s1 和 s2 底层数组已分离，互不影响。

=== 场景 2：容量充足，共享底层数组 ===
s3: [10 20 0]
s4: [20]
s3: [10 20 99]
s4: [20 99]
注意：s3[2] 被 s4 的 append 修改了，因为它们共享底层数组。

示例 2：Map 遍历与删除

本示例演示 map 的增删改查，以及在遍历中安全删除元素的语义。

package main

import "fmt"

func main() {
    // 1. 创建与初始化
    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }

    // 2. 增改查
    m["d"] = 4 // 新增
    m["a"] = 10 // 修改
    val, ok := m["b"] // 查，ok 为 true
    fmt.Printf("m['b']: %v, ok: %v\n", val, ok)

    // 3. 判断键存在
    if _, exists := m["e"]; !exists {
        fmt.Println("Key 'e' does not exist")
    }

    // 4. 遍历与删除
    fmt.Println("Before delete:")
    for k, v := range m {
        fmt.Printf("%s: %d\n", k, v)
    }

    // 在遍历中删除元素是合法的
    // 规范：未迭代到的条目被删除后，不再产出
    fmt.Println("\nDeleting 'a' during iteration:")
    for k, v := range m {
        if k == "a" {
            delete(m, k)
            fmt.Printf("Deleted %s\n", k)
        }
    }

    fmt.Println("\nAfter delete:")
    for k, v := range m {
        fmt.Printf("%s: %d\n", k, v)
    }
}

运行结果（预期输出）：

m['b']: 2, ok: true
Key 'e' does not exist
Before delete:
a: 10
b: 2
c: 3
d: 4

Deleting 'a' during iteration:
Deleted a

After delete:
b: 2
c: 3
d: 4

(注：map 遍历顺序随机，上述输出仅为一种可能情况，只要包含 b, c, d 且无 a 即可)

四、常见错误与避坑指南

五、最佳实践

六、练习题

1. 概念题： 请解释为什么 var a [5]int 和 var b [10]int 是不同类型，而 []int 和 []int 是相同类型？

2. 编码题： 编写一个函数 RemoveDuplicates，接收一个 []int 切片，返回一个去重后的 []int 切片。要求： - 结果中每个元素只出现一次。 - 保持元素在原切片中首次出现的顺序。 - 不得使用外部库。

3. 进阶/调试题： 以下代码旨在找出切片中的重复元素，但存在逻辑错误。请指出问题并修复，要求结果中每个重复元素只出现一次，且按首次重复出现的顺序输出。

```go package main

import "fmt"

func FindDuplicates(nums []int) []int { seen := make(map[int]bool) var duplicates []int for _, num := range nums { if seen[num] { duplicates = append(duplicates, num) } else { seen[num] = true } } return duplicates }

func main() { nums := []int{1, 2, 3, 2, 4, 1, 5} fmt.Println(FindDuplicates(nums)) } `` *(注：期望输出应为[2 1]`，因为 2 和 1 是重复的，且 2 先被第二次遇到，1 后被第二次遇到)*

七、练习参考答案

package main

import "fmt"

func RemoveDuplicates(nums []int) []int {
    seen := make(map[int]bool)
    var result []int
    for _, num := range nums {
        if !seen[num] {
            seen[num] = true
            result = append(result, num)
        }
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 2, 4, 1, 5}
    fmt.Println(RemoveDuplicates(nums)) // 输出: [1 2 3 4 5]
}

package main

import "fmt"

func FindDuplicates(nums []int) []int {
    seen := make(map[int]bool)
    duplicates := make(map[int]bool)
    var result []int

    for _, num := range nums {
        if seen[num] {
            // 如果已经标记为重复，则不再处理
            if !duplicates[num] {
                duplicates[num] = true
                result = append(result, num)
            }
        } else {
            seen[num] = true
        }
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 2, 4, 1, 5}
    fmt.Println(FindDuplicates(nums)) // 输出: [2 1]
}

八、本课小结