Rust向量
- 向量创建与初始化：在Rust中，使用
vec!宏或Vec::new()方法创建向量。vec!宏可初始化带有元素的向量，而Vec::new()创建空向量。 - 访问与修改向量元素：向量元素可以通过索引直接访问，或使用
get()方法安全访问。可以向 可变向量中添加元素或从中移除元素。 - 向量遍历：使用
for..in循环遍历向量，可以访问每个元素的索引和值。向量是动态大小的数据结构，支持在运行时增长和缩小。
向量是一种动态（可调整大小）的数据结构，可以存储同一类型的元素列表。作为一种可调整大小的数据结构，向量可以在运行时增长和缩小。
在 Rust 中创建向量
在 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 中创建向量
fn main() {
// 使用 vec! 宏创建向量
let v = vec![1, 2, 3];
println!("v = {:?}", v);
}
输出
v = [1, 2, 3]
注意： 我们在 println! 宏中使用 :? 来打印向量。
在 Rust 中访问向量元素
向量中的每个元素都与一个唯一的数字序列相关联。这个数字被称为向量索引。
我们可以使用向量索引来访问向量的元素。假设我们有一个颜色的向量。
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"];
// 方法 1：使用向量索引访问向量元素
println!("第一种颜色 = {}", colors[0]);
println!("第二种颜色 = {}", colors[1]);
println!("第三种颜色 = {}", colors[2]);
}
输出
第一种颜色 = blue
第二种颜色 = red
第三种颜色 = 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"];
// 方法 2：使用 get() 方法和向量索引访问向量元素
println!("第一种颜色 = {:?}", colors.get(0));
println!("第二种颜色 = {:?}", colors.get(1));
println!("第三种颜色 = {:?}", colors.get(2));
}
输出
第一种颜色 = Some("blue")
第二种颜色 = Some("red")
第三种颜色 = Some("green")
如我们所见，输出返回了 Some("blue")、Some("red") 和 Some("green") 这些 Option<T> 类型的值。
要从 Option<T> 类型中获取确切的值，我们需要展开（unwrap）该值。要了解有关展开的信息，请访问 Rust unwrap() 和 expect()。
在 Rust 中向向量添加值
我们可以通过创建一个可变的向量在 Rust 中向向量添加值。我们可以在向量赋值给变量之前使用 mut 关键字使其可变。例如，
// 可变向量
let mut v = vec![2, 4, 6, 8, 10];
我们可以使用 push() 方法向这个向量添加值。
让我们看一个例子。
fn main() {
let mut even_numbers = vec![2, 4, 6, 8, 10];
println!("原始向量 = {:?}", v);
// 在向量的末尾推入值
even_numbers.push(12);
even_numbers.push(14);
println!("变更后的向量 = {:?}", v);
}
输出
原始向量 = [2, 4, 6, 8, 10]
变更后的向量 = [2, 4, 6, 8, 10, 12, 14]
在这里，我们使用 push() 方法向向量中推入值。这只有在持有向量 even_numbers 的变量是可变的情况下才可能。
even_numbers.push(12);
even_numbers.push(14);
因此，最终的向量包括了默认元素以及12 和 14。
在 Rust 中从向量中移除值
我们可以通过使向量可变并使用 remove() 方法来从向量中移除值。例如，
fn main() {
let mut even_numbers = vec![2, 4, 6, 8, 10];
println!("原始向量 = {:?}", even_numbers);
// 从向量中的第二个索引移除值
even_numbers.remove(2);
println!("变更后的向量 = {:?}", even_numbers);
}
输出
原始向量 = [2, 4, 6, 8, 10]
更改后的向量 = [2, 4, 8, 10]
这里，我们用 even_numbers.remove(2) 方法移除了索引为 2 的值。因此，最终结果中向量不包含值 6。
注意： 移除一个元素将导致向量中所有其他值的索引向前移动一个位置（-1 索引）。
在 Rust 中遍历向量
我们可以使用 for..in 循环来遍历一个向量。例如，
fn main() {
let colors = vec!["blue", "red", "green"];
// 遍历向量以打印其索引和值
for index in 0..3 {
println!("索引: {} -- 值: {}", index, colors[index]);
}
}
输出
索引: 0 -- 值: blue
索引: 1 -- 值: red
索引: 2 -- 值: green
在上面的示例中，我们使用了范围为 0..3 的 for...in 循环。
for index in 0..3 {
...
}
这里，循环运行 3 次（0 到 2）。在每次迭代中，index 的值将分别为 0、1 和 2。我们使用这个索引来访问向量中的元素。
使用 Vec::new() 方法创建向量
另外，我们可以使用 Vec::new() 方法创建一个空向量。例如，
let v: Vec<i32> = Vec::new();
这里，我们创建了一个用于存储 i32 类型值的空向量。
let v- 变量的名称Vec<i32>- 向量的类型，其中i32是向量中所有元素的数据类型Vec::new()- 使用new()方法初始化一个空向量
示例：使用 Vec::new() 创建向量
fn main() {
// 使用 Vec::new() 方法创建向量
let mut v: Vec<i32> = Vec::new();
// 向可变向量中添加值
v.push(10);
v.push(20);
println!("v = {:?}", v);
}
输出
v = [10, 20]
这里，我们使用 Vec::new() 创建了一个可变向量，并使用向量的 push() 方法向其添加值。