Go-02-数组、切片与Map

2026-08-31

字数统计: 1.8k字 | 阅读时长≈ 8分

Go-02-数组、切片与 Map

本节目标：掌握 Go 的数组、切片（slice）、Map（哈希表）三大集合类型，理解切片的扩容机制，并初步接触泛型。

1. 数组（Array）

数组是固定长度的、值类型（赋值时复制整个底层数据）：

var a [5]int                    // 零值数组: [0 0 0 0 0]
b := [5]int{1, 2, 3, 4, 5}
c := [...]int{1, 2, 3}          // 长度自动推断为 3
d := [5]int{0: 10, 4: 50}       // 索引初始化: [10 0 0 0 50]

数组的关键特性：

长度是类型的一部分：[3]int 和 [5]int 是不同类型
是值类型，传参时会复制整个数组（大数组开销大）
大小固定，不能 append

a := [3]int{1, 2, 3}
b := a                  // 复制一份
b[0] = 100
fmt.Println(a[0])       // 1（原数组不变）
fmt.Println(b[0])       // 100

遍历：

for i, v := range a {
    fmt.Printf("a[%d] = %d\n", i, v)
}
for _, v := range a {
    fmt.Println(v)
}

多维数组：

1 2	var matrix [3][4]int matrix[1][2] = 5

2. 切片（Slice）—— Go 的核心数据结构

切片是对数组的引用，是变长的。底层结构：

type slice struct {
    Data uintptr  // 指向底层数组
    Len  int      // 长度
    Cap  int      // 容量
}

2.1 创建切片

// 从数组切
arr := [5]int{1, 2, 3, 4, 5}
s := arr[1:4]               // [2 3 4]，len=3, cap=4

// 字面量
s := []int{1, 2, 3, 4, 5}   // 自动建底层数组

// make（指定 len 和可选 cap）
s := make([]int, 5)         // len=5, cap=5, 全 0
s := make([]int, 3, 10)     // len=3, cap=10

// nil 切片（零值）
var s []int                 // nil, len=0, cap=0
// s == nil → true

2.2 切片操作

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

// 切：s[low:high]  ← 半开区间 [low, high)
fmt.Println(s[2:5])    // [2 3 4]
fmt.Println(s[:5])     // [0 1 2 3 4]
fmt.Println(s[5:])     // [5 6 7 8 9]
fmt.Println(s[:])      // 全部

// 长度和容量
fmt.Println(len(s), cap(s))  // 10 10

2.3 append：扩容

s := []int{1, 2, 3}
s = append(s, 4)             // [1 2 3 4]
s = append(s, 5, 6, 7)       // [1 2 3 4 5 6 7]
s = append(s, []int{8, 9}...) // 展开另一个切片

// append 可能触发扩容（重新分配底层数组）
// 容量增长规则（小切片大致按 2x，大切片按 1.25x，具体看 Go 版本）

2.4 copy：复制切片

src := []int{1, 2, 3, 4, 5}
dst := make([]int, 5)
n := copy(dst, src)        // 复制 5 个元素, n=5
// 不会扩容，只是按 len(dst) 复制

2.5 切片陷阱

共享底层数组导致意外修改：

arr := [5]int{1, 2, 3, 4, 5}
a := arr[0:3]              // [1 2 3]
b := arr[2:5]              // [3 4 5]
a[2] = 100
fmt.Println(b[0])          // 100 ← 同一个底层数组！

// 解决：copy 一份独立的
b := make([]int, 3)
copy(b, arr[2:5])

append 后切片还指向旧数组：

s1 := []int{1, 2, 3}
s2 := s1[:2]               // [1 2]
s2 = append(s2, 100)       // 容量够，s2 = [1 2 100]
fmt.Println(s1)            // [1 2 100] ← s1 也变了！

2.6 删除元素

Go 没有内置 delete-by-index，要自己实现：

s := []int{1, 2, 3, 4, 5}

// 删除 index=2
i := 2
s = append(s[:i], s[i+1:]...)  // [1 2 4 5]

保留顺序 vs 不保留顺序：

// 保留顺序（O(n)，慢）
s = append(s[:i], s[i+1:]...)

// 不保留顺序（O(1)，快）
s[i] = s[len(s)-1]
s = s[:len(s)-1]

3. Map（哈希表）

3.1 创建

// 字面量
m := map[string]int{
    "alice": 25,
    "bob":   30,
}

// make
m := make(map[string]int)
m["alice"] = 25

// nil map 可以读（返回零值），不能写
var m map[string]int
fmt.Println(m["x"])  // 0
// m["x"] = 1        // panic: assignment to entry in nil map

3.2 操作

m := map[string]int{"a": 1, "b": 2}

// 读
v := m["a"]                // 1
v, ok := m["a"]            // 1, true  ← 经典 comma-ok
v, ok := m["missing"]      // 0, false

// 写
m["c"] = 3

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

// 长度
fmt.Println(len(m))

// 遍历（顺序不保证）
for k, v := range m {
    fmt.Printf("%s -> %d\n", k, v)
}

3.3 Map 陷阱

Map 不是并发安全的！多 goroutine 同时读写会 panic。用 sync.Map 或加锁。
遍历顺序不保证（每次可能不同）。
Key 必须是可比较类型：bool, 数字, 字符串, 指针, 数组, 接口, 结构体（如果字段都可比较）。slice, map, func 不能作 key。

4. 字符串与字节切片

字符串是不可变的字节序列。可以用 []byte / []rune 转换：

s := "Hello, 世界"
b := []byte(s)        // [72 101 108 108 111 44 32 228 184 150 231 149 140]
r := []rune(s)        // [72 101 108 108 111 44 32 19990 30028]
fmt.Println(len(s))   // 13（字节数）
fmt.Println(len(r))   // 9（字符数）

5. 泛型入门（Go 1.18+）

Go 在 1.18 引入了泛型，类型参数用 [T any] 或 [T constraints.X] 声明：

5.1 基本泛型函数

// 任意类型的"打切片"函数
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

nums := []int{1, 2, 3}
doubled := Map(nums, func(x int) int { return x * 2 })
// [2 4 6]

strs := Map(nums, func(x int) string { return fmt.Sprintf("v=%d", x) })
// ["v=1" "v=2" "v=3"]

5.2 泛型类型

// 通用 Set
type Set[T comparable] struct {
    data map[T]struct{}
}

func NewSet[T comparable]() *Set[T] {
    return &Set[T]{data: make(map[T]struct{})}
}

func (s *Set[T]) Add(v T) {
    s.data[v] = struct{}{}
}

func (s *Set[T]) Contains(v T) bool {
    _, ok := s.data[v]
    return ok
}

func (s *Set[T]) Size() int {
    return len(s.data)
}

s := NewSet[int]()
s.Add(1)
s.Add(2)
fmt.Println(s.Contains(1))  // true
fmt.Println(s.Size())       // 2

5.3 类型约束

import "golang.org/x/exp/constraints"

// 对"可比较"类型排序（constraints.Ordered 包含所有可比较大小的类型）
func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

fmt.Println(Max(3, 5))       // 5
fmt.Println(Max(3.14, 2.7))  // 3.14
fmt.Println(Max("a", "b"))   // b

类型约束的本质：泛型让”参数多态”在编译期由编译器检查，不影响运行时性能（Go 泛型是单态化 monomorphization，不像 Java 那样擦除）。

6. 实战：手写一个 int 集合

package main

import "fmt"

func main() {
    set := make(map[int]struct{})

    // 添加
    nums := []int{1, 2, 3, 2, 4, 1, 5}
    for _, n := range nums {
        set[n] = struct{}{}
    }

    // 查
    if _, ok := set[3]; ok {
        fmt.Println("3 在集合中")
    }

    // 遍历
    for v := range set {
        fmt.Println(v)
    }

    // 集合运算
    other := map[int]struct{}{3: {}, 4: {}, 5: {}, 6: {}}
    intersection := map[int]struct{}{}
    for v := range set {
        if _, ok := other[v]; ok {
            intersection[v] = struct{}{}
        }
    }
    fmt.Println("交集：", intersection)
}

小结

集合	长度可变	值/引用	适用场景
数组 `[N]T`	❌	值	固定大小（少见）
切片 `[]T`	✅	引用（共享底层）	90% 的场景
Map `map[K]V`	✅	引用	键值查找、计数

关键心智模型：

切片是小胖手指：指向底层数组的 {ptr, len, cap} 三元组
多个切片共享底层数组 → 修改要小心
append 容量不足时扩容复制
Map 的零值是 nil，可以读不能写

下一节讲字符串处理和字符编码（UTF-8 / rune / byte 的三角关系）。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/08/31/Go-02-数组、切片与Map/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！