数组 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 的,赋值时会完整复制而不是移动。