Rust 数组

数组是相同类型元素的列表。例如，如果我们想存储前五个自然数，我们可以创建一个数组，而不是创建五个不同的变量。

在 Rust 中，我们使用方括号 [] 来创建数组。

// array of natural numbers
let arr = [1, 2, 3, 4, 5];

这里，我们创建了一个名为 arr 的数组，它包含五个数字。

在 Rust 中创建数组

在 Rust 中，我们可以通过三种不同的方式创建数组：

1. 带数据类型的数组
2. 不带数据类型的数组
3. 带默认值的数组

让我们详细了解每种数组创建方法。

Rust 中带数据类型的数组

fn main() {
    // initialization of array with data type
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    
    println!("Array of numbers = {:?}", numbers);
}

输出

Array of 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() {
    // initialization of array without data type
    let numbers = [1, 2, 3, 4, 5];
    
    println!("array of numbers = {:?}", numbers);
}

输出

Array of numbers = [1, 2, 3, 4, 5]

在上面的示例中，我们使用表达式创建了一个数字数组：

let numbers = [1, 2, 3, 4, 5];

这里，

• numbers - 数组的名称
• [1, 2, 3, 4, 5] - 数组内的元素

您可以看到我们没有定义数组的数据类型和大小。在这种情况下，Rust 编译器会根据数组元素自动识别数据类型和大小。

Rust 中带默认值的数组

fn main() {
    // initialization of array with default values
    let numbers: [i32; 5] = [3; 5];
    
    println!("Array of numbers = {:?}", numbers);
}

输出

Array of numbers = [3, 3, 3, 3, 3]

在上面的示例中，我们使用表达式创建了一个数字数组：

let numbers: [i32; 5] = [3; 5];

这里，

• numbers - 数组的名称
• [i32; 5] - 表示数组的数据类型（i32）和大小（5）
• [3; 5] - 是一个**重复表达式**，其中值 3 将填充数组 5 次

fn main() {
    // initialize array with default values
    let numbers = [3; 5];

    println!("Array of numbers = {:?}", numbers);
}

Array of numbers = [3, 3, 3, 3, 3]

复习：Rust 中创建数组的不同方法

让我们通过一个完整的示例了解如何在 Rust 中创建数组。

fn main() {
    // an array without data type
    let a = [5, 4, 3, 2, 1];
    
    // an array with data type and size
    let b: [i32; 5] = [1, 2, 3, 4, 5];
    
    // an array with default values
    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"];
    
    // accessing element at index 0
    println!("1st Color: {}", colors[0]);

    // accessing element at index 1
    println!("2nd Color: {}", colors[1]);

    // accessing element at index 2
    println!("3rd Color: {}", colors[2]);
}

输出

1st Color: red
2nd Color: green
3rd Color: blue

Rust 中的可变数组

在 Rust 中，数组是不可变的，这意味着一旦创建，我们就无法更改其元素。

但是，我们可以通过在变量名前使用 mut 关键字来创建可变数组。例如：

// create a mutable array in rust
let mut numbers: [i32; 5] = [1, 2, 3, 4, 5];

现在，我们可以对此数组进行更改。

让我们看一个例子：

fn main() {
    let mut numbers: [i32; 5] = [1, 2, 3, 4, 5];
    
    println!("original array = {:?}", array);
    
    // change the value of the 3rd element in the array
    numbers[2] = 0;
    
    println!("changed array = {:?}", numbers);
}

输出

original array = [1, 2, 3, 4, 5]
changed array = [1, 2, 0, 4, 5]

在这里，我们将数组的第三个元素的新值赋为 0。

numbers[2] = 0;

我们将索引为 2（第三个元素）的元素从 3 更改为 0。这是可能的，因为我们将 numbers 数组创建为可变的。

注意：数组内的值只能修改，不能删除，因为数组的大小在初始化后是固定的。

遍历 Rust 数组

在 Rust 中，我们可以使用 for..in 循环来遍历数组。例如：

fn main() {
    let colors = ["red", "green", "blue"];
    
    // loop through an array to print its index and value
    for index in 0..3 {
        println!("Index: {} -- Value: {}", index, colors[index]);
    }
}

输出

Index: 0 -- Value: red

Index: 1 -- Value: green
Index: 2 -- Value: blue

在上面的示例中，我们使用了带范围 0..3 的 for...in 循环。

for index in 0...3 {
    ...
}

这里，循环将执行 **3** 次（从 **0** 到 **2**）。在循环的每次迭代中，index 的值将是 **0**、**1** 和 **2**。

我们使用该索引来访问数组的元素。

fn main() {
    let array = [1, 2, 3, 4, 5];

    println!("Array Length: {}", array.len());
}

// Output: Array Length: 5