Docker7530
441 lines
8.5 KiB
Markdown
441 lines
8.5 KiB
Markdown
# Go 语言数组详解：从基础到实践
|
||
|
||
在 Go 语言中，**数组（Array）** 是最基本、最底层的数据结构之一，虽然在实际开发中我们更多使用切片（Slice），但理解数组对于深入掌握 Go 的内存模型、值传递机制和性能优化至关重要。
|
||
|
||
---
|
||
|
||
## 1. 数组基础概念
|
||
|
||
数组是 Go 中一种**固定长度、类型一致、有序存储**的集合类型。
|
||
|
||
### 核心特征
|
||
|
||
- ✅ **类型一致性**：所有元素必须是相同类型
|
||
- ✅ **固定长度**：声明后长度不可变（编译期确定）
|
||
- ✅ **值类型**：赋值和传参时会进行**深拷贝**
|
||
- ✅ **连续内存布局**：元素在内存中连续存放，有利于缓存命中
|
||
|
||
> ⚠️ 注意：`[3]int` 和 `[5]int` 是两种完全不同的类型！
|
||
|
||
---
|
||
|
||
## 2. 数组声明与初始化
|
||
|
||
### 示例 1：基本声明与初始化
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
var arr1 [5]int // 声明但未初始化，元素默认为零值
|
||
var arr2 = [5]int{1, 2, 3, 4, 5} // 显式初始化
|
||
arr3 := [5]int{10, 20, 30, 40, 50} // 简短声明
|
||
|
||
fmt.Println("arr1:", arr1) // [0 0 0 0 0]
|
||
fmt.Println("arr2:", arr2) // [1 2 3 4 5]
|
||
fmt.Println("arr3:", arr3) // [10 20 30 40 50]
|
||
}
|
||
|
||
```
|
||
|
||
---
|
||
|
||
### 示例 2：自动推导长度 `…`
|
||
|
||
Go 支持使用 `…` 让编译器自动推导数组长度。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
arr := [...]int{1, 2, 3, 4, 5} // 自动推断为 [5]int
|
||
fmt.Println("数组长度:", len(arr)) // 输出：5
|
||
fmt.Println("数组内容:", arr) // [1 2 3 4 5]
|
||
|
||
// 注意：一旦推导完成，长度依然是固定的
|
||
}
|
||
|
||
```
|
||
|
||
---
|
||
|
||
### 示例 3：指定索引初始化（稀疏数组风格）
|
||
|
||
可以跳过某些位置初始化，未指定的位置将使用零值填充。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
arr := [10]int{1: 100, 5: 500} // 第1和第5个元素被赋值
|
||
fmt.Println("指定索引初始化:", arr) // [0 100 0 0 0 500 0 0 0 0]
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### 示例 4：复合类型的数组（结构体为例）
|
||
|
||
数组不仅能存基本类型，还能存储结构体、指针、数组等复合类型。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
type Student struct {
|
||
Name string
|
||
Age int
|
||
}
|
||
|
||
func main() {
|
||
students := [2]Student{
|
||
{"Alice", 20},
|
||
{"Bob", 22},
|
||
}
|
||
|
||
fmt.Println("学生数组:", students) // [{Alice 20} {Bob 22}]
|
||
}
|
||
|
||
```
|
||
|
||
---
|
||
|
||
## 3. 数组操作详解
|
||
|
||
### 示例 5：获取长度与容量
|
||
|
||
数组的 `len()` 和 `cap()` 返回值总是相等，因为容量 == 长度。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
arr := [5]string{"a", "b", "c"}
|
||
fmt.Printf("长度: %d\n", len(arr)) // 5
|
||
fmt.Printf("容量: %d\n", cap(arr)) // 5
|
||
}
|
||
|
||
```
|
||
|
||
---
|
||
|
||
### 示例 6：安全访问与修改元素
|
||
|
||
越界访问会导致 panic！
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
arr := [3]int{10, 20, 30}
|
||
|
||
// 访问
|
||
fmt.Println("第一个元素:", arr[0]) // 10
|
||
|
||
// 修改
|
||
arr[1] = 99
|
||
fmt.Println("修改后:", arr) // [10 99 30]
|
||
|
||
// ❌ 错误示例（会 panic）—— 超出范围
|
||
// arr[5] = 100 // panic: runtime error: index out of range
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### 示例 7：遍历数组的三种方式
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
arr := [4]int{1, 3, 5, 7}
|
||
|
||
fmt.Println("1. 使用索引遍历:")
|
||
for i := 0; i < len(arr); i++ {
|
||
fmt.Printf("arr[%d] = %d\n", i, arr[i])
|
||
}
|
||
|
||
fmt.Println("\n2. 使用 range 索引:")
|
||
for i := range arr {
|
||
fmt.Printf("arr[%d] = %d\n", i, arr[i])
|
||
}
|
||
|
||
fmt.Println("\n3. 使用 range 获取索引和值:")
|
||
for idx, val := range arr {
|
||
fmt.Printf("索引 %d => 值 %d\n", idx, val)
|
||
}
|
||
|
||
fmt.Println("\n4. 忽略索引，只获取值:")
|
||
for _, val := range arr {
|
||
fmt.Printf("值: %d ", val)
|
||
}
|
||
fmt.Println()
|
||
}
|
||
|
||
```
|
||
|
||
---
|
||
|
||
## 4. 多维数组详解
|
||
|
||
### 示例 8：二维数组的声明与遍历
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
// 声明一个 3x4 的二维数组
|
||
matrix := [3][4]int{
|
||
{0, 1, 2, 3},
|
||
{4, 5, 6, 7},
|
||
{8, 9, 10, 11},
|
||
}
|
||
|
||
fmt.Println("二维数组内容:")
|
||
for i := 0; i < len(matrix); i++ {
|
||
for j := 0; j < len(matrix[i]); j++ {
|
||
fmt.Printf("%4d", matrix[i][j])
|
||
}
|
||
fmt.Println()
|
||
}
|
||
}
|
||
```
|
||
|
||
> 输出：
|
||
|
||
```
|
||
0 1 2 3
|
||
4 5 6 7
|
||
8 9 10 11
|
||
```
|
||
|
||
---
|
||
|
||
### 示例 9：三维及以上数组（了解）
|
||
|
||
虽然不常用，但 Go 支持高维数组。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
cube := [2][3][2]int{
|
||
{{1, 2}, {3, 4}, {5, 6}},
|
||
{{7, 8}, {9, 10}, {11, 12}},
|
||
}
|
||
|
||
fmt.Println("三维数组 [0][1][1]:", cube[0][1][1]) // 输出：4
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 5. 数组作为值类型的特性
|
||
|
||
这是 Go 数组最重要的特性之一：**值类型 vs 引用类型**
|
||
|
||
### 示例 10：数组赋值产生副本
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
arr1 := [4]int{1, 2, 3, 4}
|
||
arr2 := arr1 // 完整复制一份（深拷贝）
|
||
|
||
arr2[0] = 999
|
||
|
||
fmt.Println("arr1:", arr1) // [1 2 3 4] — 不受影响
|
||
fmt.Println("arr2:", arr2) // [999 2 3 4]
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### 示例 11：函数传参时的复制行为
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func modify(arr [3]int) {
|
||
arr[0] = 999
|
||
fmt.Println("函数内 arr:", arr) // [999 2 3]
|
||
}
|
||
|
||
func main() {
|
||
original := [3]int{1, 2, 3}
|
||
modify(original)
|
||
fmt.Println("函数外 original:", original) // [1 2 3] — 未改变！
|
||
}
|
||
```
|
||
|
||
> ✅ 解决方案：若需修改原始数据，应传指针：
|
||
|
||
```go
|
||
func modifyPtr(arr *[3]int) {
|
||
arr[0] = 999 // 等价于 (*arr)[0]
|
||
}
|
||
|
||
// 调用：modifyPtr(&original)
|
||
```
|
||
|
||
---
|
||
|
||
## 6. 数组的常见陷阱与注意事项
|
||
|
||
### ❌ 陷阱 1：不同长度的数组不能赋值
|
||
|
||
```go
|
||
package main
|
||
|
||
func main() {
|
||
// var a [3]int
|
||
// var b [4]int
|
||
// a = b // 编译错误：cannot use b (type [4]int) as type [3]int
|
||
}
|
||
```
|
||
|
||
虽然都是整型数组，但 `[3]int` ≠ `[4]int`，属于不同类型。
|
||
|
||
---
|
||
|
||
### ❌ 陷阱 2：大型数组传递性能差
|
||
|
||
如果数组很大（如 `[10000]int`），每次传参会复制整个数组，造成严重性能问题。
|
||
|
||
✅ 正确做法：使用指针。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func process(data *[1000]int) {
|
||
// 直接操作原数据，无复制开销
|
||
data[0] = 100
|
||
}
|
||
|
||
func main() {
|
||
largeArr := [1000]int{}
|
||
process(&largeArr)
|
||
fmt.Println("largeArr[0]:", largeArr[0]) // 100
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### ❌ 陷阱 3：无法动态扩容
|
||
|
||
数组长度固定，不能追加元素。
|
||
|
||
✅ 替代方案：使用切片（slice），它是对数组的抽象封装。
|
||
|
||
```go
|
||
slice := []int{1, 2, 3}
|
||
slice = append(slice, 4) // ✅ 可以动态增长
|
||
```
|
||
|
||
---
|
||
|
||
## 7. 最佳实践与性能建议
|
||
|
||
| 实践 | 说明 |
|
||
|------|------|
|
||
| ✅ 优先使用切片 | 绝大多数场景下应使用 `[]int` 而非 `[5]int` |
|
||
| ✅ 小数组可用值传递 | 若长度小（如 `[3]float64` 表示坐标），值传递更安全高效 |
|
||
| ✅ 大数组用指针传递 | 避免不必要的复制开销 |
|
||
| ✅ 利用连续内存优势 | 数组适合科学计算、图像处理等需缓存友好的场景 |
|
||
| ✅ 多维数组注意初始化格式 | 特别是混合维度时容易出错 |
|
||
|
||
---
|
||
|
||
## 8. 典型应用场景
|
||
|
||
### 📌 场景 1：固定配置参数
|
||
|
||
如 RGB 颜色表示：
|
||
|
||
```go
|
||
var color [3]byte = [3]byte{255, 0, 128}
|
||
```
|
||
|
||
### 📌 场景 2：哈希表键（map key）
|
||
|
||
数组如果是可比较类型，可作为 map 的 key，而切片不能。
|
||
|
||
```go
|
||
package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
// 使用 [2]int 作为 map 键
|
||
coordMap := make(map[[2]int]string)
|
||
coordMap[[2]int{0, 0}] = "origin"
|
||
coordMap[[2]int{3, 4}] = "point A"
|
||
|
||
fmt.Println(coordMap) // map[[0 0]:origin [3 4]:point A]
|
||
}
|
||
```
|
||
|
||
> ✅ 注意：只有**可比较类型**的数组才能做 key（如 `[2]int`），包含 `slice`、`map`、`func` 的数组不行。
|
||
|
||
---
|
||
|
||
### 📌 场景 3：性能敏感的底层计算
|
||
|
||
如矩阵运算、密码学哈希中的定长缓冲区：
|
||
|
||
```go
|
||
package main
|
||
|
||
import (
|
||
"crypto/sha256"
|
||
"fmt"
|
||
)
|
||
|
||
func main() {
|
||
data := []byte("hello")
|
||
hash := sha256.Sum256(data) // 返回 [32]byte 类型
|
||
fmt.Printf("SHA256: %x\n", hash)
|
||
fmt.Printf("类型是: %T\n", hash) // [32]uint8
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 总结
|
||
|
||
| 关键点 | 说明 |
|
||
|--------|------|
|
||
| 🧩 数组是 Go 的基础结构 | 了解它是理解切片的前提 |
|
||
| 🔐 值类型带来安全性 | 避免意外修改，但也带来开销 |
|
||
| ⚡ 连续内存提升性能 | 适合高性能计算场景 |
|
||
| 🚫 无法扩容 | 日常开发建议用 `slice` 代替 |
|
||
| 💡 适用于小而固定的集合 | 如坐标、颜色、哈希值等 |
|
||
|
||
> ✅ **推荐口诀**：
|
||
> 小而固定用数组，大而可变用切片；传参小心复制坑，指针优化性能佳。
|