💡 如果想阅读最新的文章，或者有技术问题需要交流和沟通，可搜索并关注微信公众号“希望睿智”。
概述
在 Rust 语言中，向量（Vector）是一种动态数组类型，可以存储相同类型的元素，并且可以在运行时改变大小。向量是 Rust 标准库中的一部分，位于 std::vec 模块中。向量是一个非常灵活和强大的数据结构，可以方便地用于各种场景，包括：存储数据、处理集合、构建动态数组等。
向量的创建
向量类型由标准库中的 Vec<T>结构体实现，这里的 T 是类型参数，代表向量能够存储任何类型的单个值，但所有元素必须是同一类型。Rust 的向量是在堆上分配的，这意味着当我们创建一个向量时，它会在堆上分配内存，而不是在栈上。因此，当向量超出作用域时，Rust 会自动释放其占用的内存，防止内存泄漏。
在 Rust 中，创建向量主要有以下 4 种方法。
1、使用 Vec::new 创建空向量。
let mut vec_number: Vec<i32> = Vec::new();
复制代码
2、使用 vec!宏创建带有初始值的向量。
fn main() { // 创建一个整数向量 let vec_number: Vec<i32> = vec![66, 99, 100]; println!("{:?}", vec_number);
// 创建一个字符串向量 let vec_str: Vec<String> = vec!["Hope".to_string(), "GitHub".to_string()]; println!("{:?}", vec_str);}
复制代码
3、使用 vec!宏创建指定长度，并初始化所有元素为相同值的向量。
fn main() { let vec_number: Vec<i32> = vec![0; 5]; // 输出：[0, 0, 0, 0, 0] println!("{:?}", vec_number);}
复制代码
4、使用 Vec::with_capacity 创建具有特定容量，但长度为 0 的向量。
fn main() { // 创建一个初始为空，但足够存储5个整型元素的向量 let mut vec_number: Vec<i32> = Vec::with_capacity(5); // 输出：[] println!("{:?}", vec_number);}
复制代码
向量的访问
访问向量的元素，可以通过索引或迭代器进行。
1、通过索引访问。注意：Rust 中的索引是基于 0 的，即第一个元素的索引是 0，最后一个元素的索引是向量长度减 1。在 Rust 中使用索引访问元素，没有运行时边界检查。如果索引超过边界，会导致程序崩溃。为了更安全地使用索引访问，避免因索引越界引发崩溃，可以使用 get()方法或 get_mut()方法，它返回一个 Option<&T>或 Option<&mut T>。
fn main() { let mut vec_number = vec![66, 99, 100]; // 访问第一个元素，输出：66 println!("{}", vec_number[0]); // 修改第二个元素 vec_number[2] = 88;
// 安全访问，当索引不存在时，不会panic if let Some(value) = vec_number.get(2) { // 输出：88 println!("{}", value); } else { println!("out of bounds"); }
// 对可变引用的安全访问，可修改向量中的元素 let mut vec_mut = vec![1, 2, 3]; if let Some(value) = vec_mut.get_mut(1) { *value = 1024; }
// 输出：[1, 1024, 3] println!("{:?}", vec_mut); // 获取向量的长度，输出：3 println!("{}", vec_mut.len()); // 清空向量，并判断向量是否为空 vec_mut.clear(); if vec_mut.is_empty() { println!("empty"); } else { println!("not empty"); }}
复制代码
2、通过迭代器访问。迭代器（Iterator）是访问向量元素的一种安全、高效且灵活的方式。通过迭代器可以遍历向量中的所有元素，并对它们执行操作，而无需关心具体的索引。iter()方法用于获取只读迭代器，iter_mut()方法用于获取可写迭代器，into_iter()方法用于消耗向量并迭代。
fn main() { let mut vec_str = vec!["Hope", "GitHub", "Gitee"];
// 使用for循环遍历向量的所有元素 for s in &vec_str { println!("{}", s); } // 使用iter()显式获取迭代器 for s in vec_str.iter() { println!("{}", s); } // 若要修改元素，需使用iter_mut()获得可变引用迭代器 for s in vec_str.iter_mut() { if s.starts_with("C") { *s = "Rust"; } }
println!("{:?}", vec_str); for s in vec_str.into_iter() { println!("{}", s); } // 到这里时，vec_str不再有效，因为它已经被消耗掉了 // println!("{:?}", vec_str);}
复制代码
向量的修改
1、添加、移除元素。使用 push 方法可以将元素添加到向量的末尾，使用 pop 方法可以从向量的末尾移除元素并返回该元素。
fn main() { let mut vec_number = vec![10, 20]; vec_number.push(66); // 输出：[10, 20, 66] println!("{:?}", vec_number);
let last_number = vec_number.pop(); // 输出：66 if let Some(value) = last_number { println!("{}", value); } else { println!("no data"); } // 输出：[10, 20] println!("{:?}", vec_number);}
复制代码
2、插入、删除元素。insert)方法用于将元素插入到指定索引位置，原有位置及之后的元素都会右移。remove()方法用于删除并返回指定索引位置的元素，之后的元素会左移填补空位。注意：插入和删除操作可能导致向量内部需要重新分配内存以适应大小的变化，这可能涉及到元素的移动；因此，对于大型数据集或性能敏感的应用，这些操作可能会有较高的时间开销。
fn main() { let mut vec_number = vec![10, 20]; // 插入元素 vec_number.insert(1, 66); // 输出：[10, 66, 20] println!("{:?}", vec_number);
// 删除元素 vec_number.remove(0); // 输出：[66, 20] println!("{:?}", vec_number);}
复制代码
向量的切片
Rust 的向量支持切片操作，这意味着，我们可以获取向量的一部分作为新的向量。切片是通过指定起始索引和结束索引来创建的，注意：包括起始索引的元素，但不包括结束索引的元素。
fn main() { let mut vec_number = vec![10, 20, 30, 40, 50];
// 获取一个切片，从索引2到4（不包括4） let slice = &mut vec_number[2..4]; // 输出：[30, 40] println!("{:?}", slice);
// 修改切片中的元素 for item in slice.iter_mut() { *item *= 2; }
// 输出：[60, 80] println!("{:?}", slice);}
复制代码
向量的排序
Rust 的向量可以通过 sort()方法或 sort_unstable()来进行排序，还可以通过 sort_by()方法或 sort_unstable_by()方法根据自定义的比较逻辑来进行排序。sort()方法是稳定的排序算法，即相同元素的相对顺序不会改变。sort_unstable()方法是不稳定的排序算法，意味着相同的元素可能会改变相对顺序，但总体上会按照给定的排序规则排序。
fn main() { let mut vec_number = vec![7, 88, 12, 36, 50];
// 默认为升序排序 vec_number.sort_unstable(); // 输出：[7, 12, 36, 50, 88] println!("{:?}", vec_number);
// 显式指定排序规则，仍然是升序 vec_number.sort_by(|a, b| a.cmp(b));
// 输出: [7, 12, 36, 50, 88] println!("{:?}", vec_number);
// 若要降序排序，反转比较结果 vec_number.sort_unstable_by(|a, b| b.cmp(a)); // 输出: [88, 50, 36, 12, 7] println!("{:?}", vec_number);}
复制代码
向量的扩展和收缩
在 Rust 中，向量提供了几种方法来管理其容量和大小。容量是向量在内存中为元素预留的空间大小，而大小则是向量当前实际包含的元素数量。当添加元素到向量时，如果当前容量不足，向量可能会自动增长其容量。但这并不意味着当我们删除元素时，向量会自动缩小其容量。
以下是向量中用于管理容量的几个方法。
1、resize 方法用于改变容量的大小。如果新的大小大于当前大小，向量会在末尾添加默认值（对于整数类型，通常是 0；对于其他类型，则依赖于其默认构造函数）。如果新的大小小于当前大小，向量会丢弃末尾的多余元素。
fn main() { let mut vec_number = vec![10, 20, 30]; // 向量为[10, 20, 30, 0, 0]，大小为5，容量可能增长以容纳更多元素 vec_number.resize(5, 0); println!("{:?}", vec_number);
// 向量为[10, 20]，大小为2，但容量可能仍然大于2 vec_number.resize(2, 0); println!("{:?}", vec_number);}
复制代码
2、reserve 方法用于确保向量至少有足够的容量来存储指定数量的元素，而不会重新分配。如果当前容量小于所需容量，向量会分配更多内存，这不会改变向量的大小。
fn main() { let mut vec_number = vec![10, 20, 30]; // 确保vec至少有20的容量，但不改变其大小和内容 vec_number.reserve(20); // 输出：[10, 20, 30] println!("{:?}", vec_number);}
复制代码
3、shrink_to_fit 方法尝试将向量的容量减少到与其大小相同。这通常在我们确定不再需要额外容量，并且希望减少内存使用时很有效。注意：这个方法并不保证一定能减少容量，某些情况下，出于性能或实现的原因，向量可能会保留一些额外的容量。
fn main() { let mut vec_number = vec![10, 20, 30]; // 将容量增加到10 vec_number.reserve(10); // 删除一个元素，现在大小是2，但容量可能仍然是10 vec_number.pop(); // 尝试将容量减少到2 vec_number.shrink_to_fit(); println!("{}", vec_number.capacity());}
复制代码
注意：在使用上述这些方法时，我们应该考虑性能开销和内存使用之间的权衡。频繁地调整向量的容量可能会导致不必要的性能开销，因此在确定确实需要调整容量时，才应该使用这些方法。
向量的连接和合并
在 Rust 中，如果想要连接或合并多个集合，可以使用 extend 方法，或者利用迭代器的 collect 方法。在下面的示例代码中，我们使用 extend 方法后，vec2 被转移了所有权，已经无效了。collect 方法通常与迭代器一起使用，用于将迭代器中的元素收集到一个集合中。
fn main() { let mut vec1 = vec![1, 2, 3]; let vec2 = vec![4, 5, 6]; // 将vec2的内容添加到vec1末尾 vec1.extend(vec2); // 输出：[1, 2, 3, 4, 5, 6] println!("{:?}", vec1); // vec2被extend函数转移了所有权，到这里时无效了 // println!("{:?}", vec2); // 创建一个新的向量来包含两个向量的内容 let vec3 = vec![1, 2, 3]; let vec4 = vec![4, 5, 6]; let vec5: Vec<i32> = vec3.into_iter().chain(vec4).collect(); // 输出：[1, 2, 3, 4, 5, 6] println!("{:?}", vec5);}
复制代码
评论