数组 Array 定义
什么是数组
数组(Array)是 Rust 中存储固定数量、相同类型元素的集合。数组的长度在编译期确定,一旦创建就不能改变。数组中的所有元素必须是同一种类型。数组的数据存储在栈上(而不是堆上),访问速度很快。
rust
fn main() {
// 创建一个包含 5 个 i32 元素的数组
let numbers = [1, 2, 3, 4, 5];
println!("{:?}", numbers); // [1, 2, 3, 4, 5]
// 数组的长度是类型的一部分
// [i32; 5] 和 [i32; 3] 是不同的类型
let three: [i32; 3] = [10, 20, 30];
let five: [i32; 5] = [10, 20, 30, 40, 50];
println!("{:?}, {:?}", three, five);
}创建数组的方式
rust
fn main() {
// 方式一:列举所有元素
let days = ["周一", "周二", "周三", "周四", "周五"];
// 方式二:重复值初始化
// [初始值; 长度] 语法,创建所有元素值相同的数组
let zeros = [0; 10]; // 10 个 0
let ones = [1.0f64; 5]; // 5 个 1.0
let spaces = [' '; 20]; // 20 个空格
println!("{:?}", zeros); // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
// 方式三:带类型标注
let scores: [f64; 4] = [85.5, 92.0, 78.3, 95.7];
println!("{:?}", scores);
// 方式四:空数组(长度为 0)
let empty: [i32; 0] = [];
println!("空数组长度:{}", empty.len()); // 0
println!("{:?}", days);
}访问数组元素
rust
fn main() {
let months = [
"一月", "二月", "三月", "四月", "五月", "六月",
"七月", "八月", "九月", "十月", "十一月", "十二月",
];
// 用索引访问,索引从 0 开始
let first = months[0]; // "一月"
let last = months[11]; // "十二月"
println!("第一个月:{},最后一个月:{}", first, last);
// 获取数组长度
println!("数组长度:{}", months.len()); // 12
// 检查数组是否为空
println!("是否为空:{}", months.is_empty()); // false
// 越界访问会在运行时 panic
// let bad = months[12]; // panic: index out of bounds
// 用 get() 方法安全访问(返回 Option)
match months.get(5) {
Some(month) => println!("第 6 个月:{}", month),
None => println!("索引越界"),
}
match months.get(20) {
Some(month) => println!("{}", month),
None => println!("索引 20 越界了"),
}
}修改数组元素
rust
fn main() {
// 数组必须声明为 mut 才能修改元素
let mut scores = [60, 70, 80, 90, 100];
println!("修改前:{:?}", scores);
scores[0] = 95; // 修改第一个元素
scores[4] = 65; // 修改最后一个元素
println!("修改后:{:?}", scores);
// 用循环批量修改
for i in 0..scores.len() {
scores[i] += 5; // 每个成绩加 5 分
}
println!("加分后:{:?}", scores);
}遍历数组
rust
fn main() {
let fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"];
// 方式一:for 循环遍历引用
println!("遍历引用:");
for fruit in &fruits {
print!("{} ", fruit);
}
println!();
// 方式二:带索引遍历
println!("带索引遍历:");
for (i, fruit) in fruits.iter().enumerate() {
println!(" {} -> {}", i, fruit);
}
// 方式三:使用 iter() 方法链
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let sum: i32 = numbers.iter().sum();
let even_count = numbers.iter().filter(|&&n| n % 2 == 0).count();
println!("总和:{},偶数个数:{}", sum, even_count);
}数组与栈内存
数组存储在栈上,大小在编译期确定。这意味着数组不能动态改变长度,但访问效率高。
rust
fn main() {
// 数组在栈上的内存布局
let arr: [i32; 4] = [10, 20, 30, 40];
// 整个数组占用 4 * 4 = 16 字节
println!("[i32; 4] 大小:{} 字节", std::mem::size_of::<[i32; 4]>());
// 数组实现了 Copy trait(前提是元素类型实现了 Copy)
let arr2 = arr; // 复制,不是移动
println!("原数组:{:?}", arr); // 仍然可用
println!("复制的:{:?}", arr2);
}基本示例
计算学生成绩的统计信息:
rust
fn main() {
// 5 个学生的考试成绩
let scores: [f64; 5] = [85.5, 92.0, 78.3, 95.7, 88.1];
// 计算总分
let total: f64 = scores.iter().sum();
// 计算平均分
let average = total / scores.len() as f64;
// 找最高分和最低分
// 浮点数不能直接用 max/min,需要用 fold 或手动比较
let mut highest = scores[0];
let mut lowest = scores[0];
for &score in &scores {
if score > highest { highest = score; }
if score < lowest { lowest = score; }
}
// 统计及格(>=60)的人数
let pass_count = scores.iter().filter(|&&s| s >= 60.0).count();
println!("成绩:{:?}", scores);
println!("总分:{:.1}", total);
println!("平均分:{:.1}", average);
println!("最高分:{:.1}", highest);
println!("最低分:{:.1}", lowest);
println!("及格人数:{}/{}", pass_count, scores.len());
}常见问题
问题一:数组和 Vec 有什么区别?
| 对比项 | 数组 [T; N] | Vec Vec<T> |
|---|---|---|
| 长度 | 编译期固定 | 运行时可变 |
| 存储位置 | 栈 | 堆 |
| 长度是类型的一部分 | 是 | 否 |
| 添加/删除元素 | 不行 | 可以 |
| 性能 | 略快(无堆分配) | 稍慢(有堆分配) |
| 适用场景 | 大小已知且固定 | 大小不确定或需要动态增长 |
问题二:数组长度必须是编译期常量吗?
是的。[i32; n] 中的 n 必须是编译期可确定的值(字面量、const 常量等)。如果需要运行时确定大小的集合,用 Vec。
问题三:数组越界访问会怎样?
编译期能发现的越界(如 let x = arr[100]; 其中 arr 只有 5 个元素)会在编译时报错。运行时越界会 panic。用 .get(index) 方法可以安全地访问,返回 Option。
问题四:[0; 100] 这种初始化方式对复杂类型有限制吗?
[value; N] 要求 value 的类型实现了 Copy trait。[0; 100] 没问题因为 i32 是 Copy 的。但 [String::from("hello"); 5] 不行,因为 String 不是 Copy 的。
适用场景
- 固定大小的数据集:一周七天、RGB 三通道、月份列表等
- 缓冲区:
[u8; 1024]作为固定大小的读取缓冲区 - 矩阵和向量:
[[f64; 3]; 3]表示 3x3 矩阵 - 查找表:编译期已知的映射关系
- 嵌入式开发:栈上分配,不依赖堆分配器
注意事项
- 数组长度是类型的一部分,
[i32; 3]和[i32; 5]是不同类型 [value; N]初始化要求类型实现Copy- 运行时索引越界会 panic,安全访问用
.get() - 大数组放在栈上可能导致栈溢出,超大数组应该用
Vec放到堆上 - 数组传给函数时如果不用引用会复制整个数组(
Copy类型),大数组应该传引用 - 多维数组用嵌套数组表示:
[[T; COLS]; ROWS]
总结
数组是 Rust 中固定长度、相同类型元素的集合,存储在栈上,长度是类型的一部分。创建数组可以逐个列举元素或用 [值; 长度] 语法批量初始化。通过下标索引访问元素,越界会 panic,安全访问用 .get() 方法。数组适合大小在编译期确定的场景,如果需要运行时动态增长应该用 Vec。数组的元素类型如果是 Copy 的,整个数组也是 Copy 的,赋值时会完整复制而不是移动。