Rust 数组
- 数组定义和初始化：Rust 中的数组是相同类型元素的集合，可通过不同方式初始化，包括带数据类型、不带数据类型和带默认值。
- 访问和修改数组元素：数组元素通过索引访问，可使用
mut关键字创建可变数组，允许修改但不允许增删元素。 - 数组的遍历和特性：使用
for..in循环遍历数组，Rust 数组具有固定大小、同类型元素、顺序存储等特性。
数组是相同类型元素的列表。例如，如果我们想存储前五个自然数，我们可以创建一个数组，而不是创建五个不同的变量。
在 Rust 中，我们使用方括号 [] 来创建数组。
// 自然数数组
let arr = [1, 2, 3, 4, 5];
这里，我们创建了一个名为 arr 的数组，它包含五个数字。
在 Rust 中创建数组
在 Rust 中，我们可以通过三种不同的方式来创建数组：
- 带数据类型的数组
- 不带数据类型的数组
- 带默认值的数组
让我们详细了解这些数组创建方法。
Rust 中带数据类型的数组
fn main() {
// 使用数据类型初始化数组
let numbers: [i32; 5] = [1, 2, 3, 4, 5];
println!("数字数组 = {:?}", numbers);
}
输出
数字数组 = [1, 2, 3, 4, 5]
在上述示例中，我们使用以下表达式创建了一个数字数组，
let numbers: [i32; 5] = [1, 2, 3, 4, 5];
这里，
numbers- 数组的名称[i32; 5]-i32是数组元素的预定义数据类型，5是数组的大小[1, 2, 3, 4, 5]- 数组内的元素
Rust 中不带数据类型的数组
fn main() {
// 不使用数据类型初始化数组
let numbers = [1, 2, 3, 4, 5];
println!("数字数组 = {:?}", numbers);
}
输出
数字数组 = [1, 2, 3, 4, 5]
在上述示例中，我们使用以下表达式创建了一个数字数组，
let numbers = [1, 2, 3, 4, 5];
这里，
numbers- 数组的名称[1, 2, 3, 4, 5]- 数组内的元素
你可以看到我们没 有定义数组的数据类型和大小。在这种情况下，Rust 编译器会自动根据数组元素识别数据类型和大小。
Rust 中带默认值的数组
fn main() {
// 使用默认值初始化数组
let numbers: [i32; 5] = [3; 5];
println!("数字数组 = {:?}", numbers);
}
输出
数字数组 = [3, 3, 3, 3, 3]
在上述示例中，我们使用以下表达式创建了一个数字数组，
let numbers: [i32; 5] = [3; 5];
这里，
numbers- 数组的名称[i32; 5]- 表示数组的数据类型（i32）和大小（5）[3; 5]- 是一个重复表达式，这里的值3将填充数组5次
注意： 在创建默认值的数组时，我们也可以省略数据类型和大小。例如，
fn main() {
// 使用默认值初始化数组
let numbers = [3; 5];
println!("数字数组 = {:?}", numbers);
}
输出
数字数组 = [3, 3, 3, 3, 3]
复习：Rust 中创建数组的不同方式
让我们看一个完整的例子，展示如何在 Rust 中创建数组。
fn main() {
// 不带数据类型的数组
let a = [5, 4, 3, 2, 1];
// 带数据类型和大小的数组
let b: [i32; 5] = [1, 2, 3, 4, 5];
// 带默认值的数组
let c = [3; 5];
println!("a = {:?}", a);
println!("b = {:?}", b);
println!("c = {:?}", c);
}
输出
a = [5, 4, 3, 2, 1]
b = [1, 2, 3, 4, 5]
c = [3, 3, 3, 3, 3]
注意： 我们在 println! 函数中使用 :? 来打印整个数组。
访问 Rust 数组的元素
数组中的每个元素都与一个唯一的序列号相关联。这个数字被称为数组索引。
假设我们有一个颜色数组，
let colors = ["red", "green", "blue"];
数组索引的样子如下：
在 Rust 中，我们可以使用相应的数组索引来访问单个数组元素。例如，
colors[0]- 访问索引 0 处的元素（第一个元素）colors[1]- 访问索引 1 处的元素（第二个元素）colors[2]- 访问索引 2 处的元素（第三个元素）
注意： 数组索引始终从 0 开始；因此，数组的第一个元素位于位置 0，而不是 1。
示例：访问数组元素
fn main() {
let colors = ["red", "green", "blue"];
// 访问索引 0 处的元素
println!("第一种颜色：{}", colors[0]);
// 访问索引 1 处的元素
println!("第二种颜色：{}", colors[1]);
// 访问索引 2 处的元素
println!("第三种颜色：{}", colors[2]);
}
输出
第一种颜色：red
第二种颜色：green
第三种颜色：blue
Rust 中的可变数组
在 Rust 中，数组是不可变的，这意味着一旦创建就无法更改其元素。
然而，我们可以通过在变量前使用 mut 关键字来创建一个可变数组。例如，
// 在 Rust 中创建一个可变数组
let mut numbers: [i32; 5] = [1, 2, 3, 4, 5];
现在，我们可以对这个数组进行更改。
让我们看一个例子，
fn main() {
let mut numbers: [i32; 5] = [1, 2, 3, 4, 5];
println!("原始数组 = {:?}", array);
// 更改数组中第 3 个元素的值
numbers[2] = 0;
println!("更改后的数组 = {:?}", numbers);
}
输出
原始数组 = [1, 2, 3, 4, 5]
更改后的数组 = [1, 2, 0, 4, 5]
在这里，我们将数组中第三个元素的新值设为了 0。
numbers[2] = 0;
我们将索引 2 的元素（第三个元素）从 3 更改为了 0。这是因为我们创建的 numbers 数组是可变的。
注意： 数组中的值只能被修改，不能被删除，因为数组的大小在初始化后是固定的。
在 Rust 中遍历数组
在 Rust 中，我们可以使用 for..in 循环遍历数组。例如，
fn main() {
let colors = ["red", "green", "blue"];
// 循环遍历数组以打印其索引和值
for index in 0..3 {
println!("索引: {} -- 值: {}", index, colors[index]);
}
}
输出
索引: 0 -- 值: red
索引: 1 -- 值: green
索引: 2 -- 值: blue
在上面的示例中，我们使用了 0..3 范围的 for...in 循环。
for index in 0...3 {
...
}
这里，循环运行了 3 次（ 0 到 2）。在循环的每次迭代中，index 的值将分别是 0、1 和 2。
我们使用这个索引来访问数组的元素。
常见问题
我们能在 Rust 中创建动态数组吗？
在动态数组中，没有确定的大小，我们可以向数组中添加尽可能多的元素。
然而，Rust 不允许我们创建动态数组，因为编译器需要定义大小来为数组分配空间。
数组的一些特性是什么？
Rust 中数组的一些特性如下：
- 数组只能包含同一数据类型的元素。
- 我们必须在使用数组之前定义数组的大小，并且在初始化后不能改变它。
- 数组元素存储在顺序内存块中的堆栈中。
- 数组的每个元素都与一个唯一的数字相关联，称为数组索引，我们使用数组索引来访问数组中的关联元素。
我们如何在 Rust 中找出数组的长度？
我们可以使用 len 方法来找出 Rust 数组的长度。例如，
fn main() {
let array = [1, 2, 3, 4, 5];
println!("数组长度: {}", array.len());
}
// 输出：数组长度: 5