Vec<T> 动态数组
什么是 Vec<T>
Vec<T>(读作 "vector of T")是 Rust 中最常用的集合类型,它是一个可以动态增长和缩减的数组。T 是元素类型,所有元素必须是同一种类型。Vec 的数据存储在堆上,由三部分组成:指向堆内存的指针、当前元素数量(长度)和已分配的总容量。
和固定长度的数组 [T; N] 不同,Vec 可以在运行时添加、删除元素,长度不需要在编译期确定。
fn main() {
// 创建一个 Vec
let mut numbers: Vec<i32> = Vec::new();
numbers.push(1);
numbers.push(2);
numbers.push(3);
println!("{:?}", numbers); // [1, 2, 3]
// Vec 变量在栈上占 24 字节(指针 + 长度 + 容量)
println!("Vec<i32> 变量大小:{} 字节", std::mem::size_of::<Vec<i32>>()); // 24
println!("长度:{},容量:{}", numbers.len(), numbers.capacity());
}创建 Vec 的方式
fn main() {
// 方式一:Vec::new() 创建空 Vec
let mut v1: Vec<i32> = Vec::new();
v1.push(1);
// 方式二:vec! 宏(最常用)
let v2 = vec![1, 2, 3, 4, 5];
// 方式三:vec! 宏 + 重复值
let v3 = vec![0; 10]; // 10 个 0
println!("{:?}", v3); // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
// 方式四:预分配容量
let v4: Vec<String> = Vec::with_capacity(100);
println!("长度:{},容量:{}", v4.len(), v4.capacity()); // 长度 0,容量 100
// 方式五:从迭代器收集
let v5: Vec<i32> = (1..=5).collect();
println!("{:?}", v5); // [1, 2, 3, 4, 5]
// 方式六:从数组或切片转换
let arr = [10, 20, 30];
let v6 = arr.to_vec();
let v7 = Vec::from([40, 50, 60]);
println!("{:?}, {:?}", v6, v7);
println!("{:?}, {:?}", v1, v2);
}访问元素
fn main() {
let v = vec![10, 20, 30, 40, 50];
// 方式一:索引访问(越界会 panic)
let first = v[0];
let third = v[2];
println!("第一个:{},第三个:{}", first, third);
// 方式二:get() 方法(安全访问,返回 Option)
match v.get(2) {
Some(val) => println!("索引 2 的值:{}", val),
None => println!("索引越界"),
}
match v.get(100) {
Some(val) => println!("{}", val),
None => println!("索引 100 越界了"),
}
// 获取第一个和最后一个
println!("第一个:{:?}", v.first()); // Some(&10)
println!("最后一个:{:?}", v.last()); // Some(&50)
// 切片访问
let slice: &[i32] = &v[1..4];
println!("切片:{:?}", slice); // [20, 30, 40]
}添加和删除元素
fn main() {
let mut v = vec![1, 2, 3];
// push:在末尾添加
v.push(4);
v.push(5);
println!("push 后:{:?}", v); // [1, 2, 3, 4, 5]
// pop:移除并返回最后一个元素
let last = v.pop();
println!("pop:{:?},剩余:{:?}", last, v); // Some(5), [1, 2, 3, 4]
// insert:在指定位置插入(后面的元素后移)
v.insert(1, 10);
println!("insert 后:{:?}", v); // [1, 10, 2, 3, 4]
// remove:移除指定位置的元素(后面的元素前移)
let removed = v.remove(1);
println!("remove {},剩余:{:?}", removed, v); // [1, 2, 3, 4]
// retain:保留满足条件的元素
v.retain(|&x| x > 2);
println!("retain 后:{:?}", v); // [3, 4]
// extend:批量添加
v.extend([5, 6, 7]);
println!("extend 后:{:?}", v); // [3, 4, 5, 6, 7]
// clear:清空所有元素
v.clear();
println!("clear 后:{:?},长度:{}", v, v.len()); // [], 0
// truncate:截断到指定长度
let mut w = vec![1, 2, 3, 4, 5];
w.truncate(3);
println!("truncate 后:{:?}", w); // [1, 2, 3]
}遍历 Vec
fn main() {
let v = vec![10, 20, 30, 40, 50];
// 方式一:不可变引用遍历
for val in &v {
print!("{} ", val);
}
println!();
// 方式二:带索引遍历
for (i, val) in v.iter().enumerate() {
println!("v[{}] = {}", i, val);
}
// 方式三:可变引用遍历(修改元素)
let mut v2 = vec![1, 2, 3, 4, 5];
for val in &mut v2 {
*val *= 2; // 每个元素乘以 2
}
println!("翻倍后:{:?}", v2); // [2, 4, 6, 8, 10]
// 方式四:消耗式遍历(获取所有权)
let v3 = vec![String::from("a"), String::from("b"), String::from("c")];
for s in v3 {
// s 是 String(拥有所有权),不是引用
println!("拥有:{}", s);
}
// v3 已经被消耗,不能再使用
// println!("{:?}", v3); // 编译错误
}常用方法
fn main() {
let v = vec![3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
// 长度和容量
println!("长度:{}", v.len());
println!("容量:{}", v.capacity());
println!("为空:{}", v.is_empty());
// 是否包含某个值
println!("包含 5:{}", v.contains(&5));
println!("包含 7:{}", v.contains(&7));
// 排序
let mut sorted = v.clone();
sorted.sort();
println!("排序后:{:?}", sorted);
// 去重(必须先排序)
sorted.dedup();
println!("去重后:{:?}", sorted);
// 反转
let mut reversed = v.clone();
reversed.reverse();
println!("反转:{:?}", reversed);
// 迭代器方法
let sum: i32 = v.iter().sum();
let max = v.iter().max();
let min = v.iter().min();
let count = v.iter().filter(|&&x| x > 3).count();
println!("总和:{},最大:{:?},最小:{:?},大于3的个数:{}", sum, max, min, count);
// map + collect 转换
let doubled: Vec<i32> = v.iter().map(|&x| x * 2).collect();
println!("翻倍:{:?}", doubled);
// 二分查找(数据必须已排序)
let sorted_data = vec![1, 3, 5, 7, 9, 11];
println!("查找 7:{:?}", sorted_data.binary_search(&7)); // Ok(3)
println!("查找 6:{:?}", sorted_data.binary_search(&6)); // Err(3)
}容量管理
Vec 在元素个数超过容量时会自动扩容(通常是当前容量的 2 倍),但扩容涉及堆内存重新分配和数据复制,有一定开销。如果预知大致的元素个数,用 with_capacity 预分配可以避免频繁扩容。
fn main() {
// 不预分配:会多次扩容
let mut v1 = Vec::new();
println!("初始容量:{}", v1.capacity()); // 0
for i in 0..20 {
v1.push(i);
// 容量增长规律(大致):0, 4, 8, 16, 32...
}
println!("20个元素后容量:{}", v1.capacity()); // 32
// 预分配:一次到位
let mut v2 = Vec::with_capacity(20);
for i in 0..20 {
v2.push(i);
}
println!("预分配后容量:{}", v2.capacity()); // 20(刚好够用,没有浪费)
// 收缩多余容量
let mut v3 = Vec::with_capacity(100);
v3.extend(0..5);
println!("收缩前:长度={},容量={}", v3.len(), v3.capacity());
v3.shrink_to_fit();
println!("收缩后:长度={},容量={}", v3.len(), v3.capacity());
// 手动扩容
let mut v4 = vec![1, 2, 3];
v4.reserve(100); // 确保至少还能放 100 个元素
println!("reserve 后容量:{}", v4.capacity());
}基本示例
简易的学生成绩管理:
struct Student {
name: String,
scores: Vec<f64>,
}
impl Student {
// 创建新学生
fn new(name: &str) -> Self {
Student {
name: name.to_string(),
scores: Vec::new(),
}
}
// 添加成绩
fn add_score(&mut self, score: f64) {
self.scores.push(score);
}
// 计算平均分
fn average(&self) -> f64 {
if self.scores.is_empty() {
return 0.0;
}
let sum: f64 = self.scores.iter().sum();
sum / self.scores.len() as f64
}
// 最高分
fn highest(&self) -> Option<f64> {
self.scores.iter().cloned().reduce(f64::max)
}
// 最低分
fn lowest(&self) -> Option<f64> {
self.scores.iter().cloned().reduce(f64::min)
}
}
fn main() {
let mut students: Vec<Student> = Vec::new();
// 添加学生和成绩
let mut s1 = Student::new("张三");
s1.add_score(85.5);
s1.add_score(92.0);
s1.add_score(78.3);
students.push(s1);
let mut s2 = Student::new("李四");
s2.add_score(90.0);
s2.add_score(88.5);
s2.add_score(95.7);
students.push(s2);
// 打印成绩报告
for student in &students {
println!("{}:", student.name);
println!(" 成绩:{:?}", student.scores);
println!(" 平均分:{:.1}", student.average());
println!(" 最高分:{:.1}", student.highest().unwrap_or(0.0));
println!(" 最低分:{:.1}", student.lowest().unwrap_or(0.0));
}
// 按平均分排序(从高到低)
students.sort_by(|a, b| {
b.average().partial_cmp(&a.average()).unwrap()
});
println!("\n排名:");
for (i, student) in students.iter().enumerate() {
println!(" 第 {} 名:{} ({:.1}分)", i + 1, student.name, student.average());
}
}常见问题
问题一:Vec 和数组有什么区别?
| 对比项 | [T; N] 数组 | Vec<T> 动态数组 |
|---|---|---|
| 长度 | 编译期固定 | 运行时可变 |
| 存储位置 | 栈 | 堆 |
| 长度是类型的一部分 | 是 | 否 |
| 添加/删除元素 | 不可以 | 可以 |
| Copy trait | 元素是 Copy 时可以 | 不行(赋值是移动) |
| 适用场景 | 大小已知且固定 | 大小不确定或需要动态增长 |
问题二:push 和 insert 的性能区别?
push 在末尾添加,时间复杂度是 O(1)(平摊,偶尔扩容是 O(n))。insert 在中间插入,需要移动后面所有元素,时间复杂度是 O(n)。频繁在中间插入考虑用 VecDeque 或 LinkedList。
问题三:遍历时能修改 Vec 的长度吗?
用 for 循环遍历时不能 push 或 remove,因为迭代器持有 Vec 的借用。如果需要在遍历时增删元素,用 retain 方法(删除)、先收集索引再操作,或者用 while 循环手动控制索引。
问题四:Vec 离开作用域时会释放内存吗?
会。Vec 实现了 Drop trait,离开作用域时会自动释放堆上的内存。如果元素类型也有 Drop(比如 Vec<String>),每个元素也会被逐个释放。
适用场景
- 动态集合:元素数量在运行时确定的场景
- 缓冲区:读取文件或网络数据时的缓冲区
- 数据处理管道:配合迭代器方法(map、filter、collect)处理数据
- 栈结构:用 push/pop 实现后进先出
- 排序和搜索:sort + binary_search 实现有序数据的快速查找
- 字符串构建:
Vec<u8>可以用来构建字节缓冲区
注意事项
- Vec 不实现
Copy,赋值和传参是移动所有权。需要保留原数据用.clone() - 索引越界会 panic,安全访问用
.get()方法 - 预知元素数量时用
Vec::with_capacity()预分配容量 insert和remove在大 Vec 的开头或中间操作很慢(O(n))- 遍历过程中不能修改 Vec 的长度
- 浮点数的 Vec 不能直接
.sort(),需要用.sort_by()配合partial_cmp - 空 Vec 不占堆内存(
Vec::new()不会分配),第一次 push 时才分配
总结
Vec<T> 是 Rust 中最常用的集合类型,是一个可以在运行时动态增长和缩减的数组,数据存储在堆上。用 vec! 宏或 Vec::new() 创建,用 push/pop 在末尾增删,用 insert/remove 在任意位置操作。Vec 提供了丰富的方法来排序、搜索、过滤和转换数据,配合迭代器方法可以写出简洁的数据处理代码。使用 Vec 时主要注意两点:预知大小时用 with_capacity 预分配容量以减少扩容开销,以及通过 .get() 方法安全地访问元素避免越界 panic。