Vec<T> 动态数组 ​

什么是 Vec<T> ​

Vec<T>(读作 "vector of T")是 Rust 中最常用的集合类型,它是一个可以动态增长和缩减的数组。T 是元素类型,所有元素必须是同一种类型。Vec 的数据存储在堆上,由三部分组成:指向堆内存的指针、当前元素数量(长度)和已分配的总容量。

和固定长度的数组 [T; N] 不同,Vec 可以在运行时添加、删除元素,长度不需要在编译期确定。

rust
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 的方式 ​

rust
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);
}

访问元素 ​

rust
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]
}

添加和删除元素 ​

rust
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 ​

rust
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);  // 编译错误
}

常用方法 ​

rust
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 预分配可以避免频繁扩容。

rust
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());
}

基本示例 ​

简易的学生成绩管理:

rust
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。