Rust 向量

Vector 是一种动态（可调整大小）的数据结构，可以存储相同类型的元素列表。作为一种可调整大小的数据结构，向量可以在运行时增长和缩小。

在 Rust 中创建 Vector

在 Rust 中，我们可以使用 vec! 宏创建向量。例如，

let v = vec![1, 2, 3];

在这里，我们使用带有某些初始值的 vec! 宏来创建一个向量。

• let v - 变量名
• vec![1, 2, 3] - 使用整数值1、2、3初始化向量

通过查看宏提供的值的类型，Rust 会自动设置向量的类型。例如，上述向量的向量类型是 Vec<i32>。

我们也可以使用 vec! 宏自己定义向量类型。

let v: Vec<u8> = vec![1, 2, 3];

在这里，我们创建了一个类型为 u8 的向量，其元素为1、2和3。

示例：在 Rust 中创建 Vector

fn main() {    
    // vector creation with vec! macro
    let v = vec![1, 2, 3];
    
    println!("v2= {:?}", v);
}

输出

v = [1, 2, 3]

注意：由于 Rust Vectors 实现 Debug trait，我们可以在 println! 宏中使用 :? 来打印向量。

在 Rust 中访问 Vector 的元素

向量中的每个元素都与一个唯一的数字序列相关联。这个数字称为向量索引。

我们可以使用向量索引来访问向量的元素。假设我们有一个颜色向量。

let colors = vec!["blue", "red", "green"];

这个向量的索引看起来像这样，

我们可以使用相应的向量索引访问各个向量元素。例如，

• colors[0] - 访问索引 0（第一个元素）处的元素
• colors[1] - 访问索引 1（第二个元素）处的元素
• colors[2] - 访问索引 2（第三个元素）处的元素

注意：向量索引始终从0开始；因此，数组的第一个元素位于位置0，而不是1。

示例：使用向量索引访问向量的元素

fn main() {
    let colors = vec!["blue", "red", "green"];
    
    // method 1: access vector elements using vector index
    println!("first color = {}", colors[0]);
    println!("second color = {}", colors[1]);
    println!("third color = {}", colors[2]);
}

输出

first color = blue
second color = red
third color = green

在 Rust 中使用 get() 方法访问向量的元素

我们还可以使用 get() 方法和元素的索引来访问向量的元素。

假设我们有一个颜色向量

let colors = vec!["blue", "red", "green"];

我们可以使用 get() 来访问此向量的元素。 get() 方法不直接返回向量元素，而是返回一个类型为 Option<T> 的枚举。结果是 Some(T) 或 None。

• colors.get(0) - 返回索引 0处的 Some 值
• colors.get(1) - 返回索引 1处的 Some 值
• colors.get(2) - 返回索引 2处的 Some 值

与直接使用向量索引访问元素相比，使用 get() 方法的优点是，如果向量索引越界，它不会出错。

假设我们越过了向量索引范围；那么 get() 将返回 None。例如，

colors.get(3) 将返回 None

示例：使用 get() 访问向量的元素

fn main() {
    let colors = vec!["blue", "red", "green"];
    
    // method 2: access vector elements using get() method and vector index
    println!("first color = {:?}", colors.get(0));
    println!("second color = {:?}", colors.get(1));
    println!("third color = {:?}", colors.get(2));
}

输出

first color = Some("blue")
second color = Some("red")
third color = Some("green")

如我们所见，输出返回了 Option<T> 类型的 Some("blue")、Some("red") 和 Some("green") 值。

要从 Option<T> 类型中获取确切的值，我们需要解包该值。要了解 unwrap，请访问 Rust unwrap() and expect()。

在 Rust 中向 Vector 添加值

我们可以通过在 Rust 中创建一个可变向量来添加值。我们可以使用 mut 关键字在将向量分配给变量之前，将其设为可变。例如，

// mutable vector
let mut v = vec![2, 4, 6, 8, 10];

我们可以使用 push() 方法将值添加到此向量中。

让我们看一个例子。

fn main() {
    let mut even_numbers = vec![2, 4, 6, 8, 10];
    
    println!("original vector = {:?}", v);
    
    // push values at the end of the vector
    even_numbers.push(12);
    even_numbers.push(14);
    
    println!("changed vector = {:?}", v);
}

输出

original vector = [2, 4, 6, 8, 10]
changed vector = [2, 4, 6, 8, 10, 12, 14]

在这里，我们使用 push() 方法将值推送到向量中。这之所以可能，是因为持有向量 even_numbers 的变量是可变的。

even_numbers.push(12);
even_numbers.push(14);

结果，最终的向量包括默认元素12和14。

在 Rust 中从 Vector 中删除值

我们可以通过使其可变并使用 remove() 方法来从向量中删除值。例如，

fn main() {
    let mut even_numbers = vec![2, 4, 6, 8, 10];
    
    println!("original vector = {:?}", even_numbers);
    
    // remove value from the vector in its second index
    even_numbers.remove(2);
    
    println!("changed vector = {:?}", even_numbers);
}

输出

original vector = [2, 4, 6, 8, 10]
changed vector = [2, 4, 8, 10]

在这里，我们使用 even_numbers.remove(2) 方法移除了第二个索引处的值。因此，最终结果不包含向量中的值6。

注意：删除元素将把该元素之后的所有其他值向前移动一个位置（-1 索引）。

在 Rust 中循环遍历 Vector

我们可以使用 for 循环来遍历向量。例如，

fn main() {
    let colors = vec!["blue", "red", "green"];
    
    let mut index = 0;
    
    // loop through a vector to print its index and value
    for color in colors {
        println!("Index: {} -- Value: {}", index, color);
        index = index + 1;
    }
}

输出

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

在上面的例子中，我们使用了 for 循环。

for color in colors {
    ...
}

这里，循环运行3次（向量元素的总数）。

在循环的每次迭代中，color 的值将分别设置为blue、red和green。同样，我们使用了一个索引变量来表示每个向量元素的索引。

注意：与使用 [] 运算符访问向量元素相比，应优先使用 for 循环，因为使用 [] 访问由于越界检查会产生运行时开销。

使用 Vec::new() 方法创建 Vector

或者，我们可以使用 Vec::new() 方法创建一个空向量。例如，

let v: Vec<i32> = Vec::new();

在这里，我们创建了一个空的向量来存储 i32 类型的值。

• let v - 变量名
• Vec<i32> - 向量的类型，其中 i32 是向量中所有元素的数1据类型
• Vec::new() - 使用 new() 方法初始化一个空向量

示例：使用 Vec::new() 创建 Vector

fn main() {
    // vector creation with Vec::new() method
    let mut v: Vec<i32> = Vec::new();

    // push values to a mutable vector
    v.push(10);
    v.push(20);

    println!("v = {:?}", v);
}

输出

v = [10, 20]

在这里，我们使用 Vec::new() 创建了一个可变向量，并使用向量的 push() 方法向其中添加值。