Rust Vec 初始化方法

Vec（动态数组）是 Rust 中最常用的集合类型。以下是各种初始化方法：

基本初始化

// 创建空 Vec
let mut vec1: Vec<i32> = Vec::new();
let mut vec2 = Vec::<i32>::new();

// 使用 vec! 宏
let vec3 = vec![1, 2, 3, 4, 5];
let vec4 = vec![0; 5];  // [0, 0, 0, 0, 0]

指定容量

// 预分配容量，避免重复分配
let mut vec5 = Vec::with_capacity(10);

// 检查容量和长度
println!("容量: {}, 长度: {}", vec5.capacity(), vec5.len());

从其他集合创建

// 从数组
let arr = [1, 2, 3, 4];
let vec6 = arr.to_vec();
let vec7 = Vec::from(arr);

// 从切片
let slice = &[1, 2, 3];
let vec8 = slice.to_vec();

// 从迭代器
let vec9: Vec<i32> = (1..=5).collect();
let vec10 = vec![1, 2, 3].into_iter().map(|x| x * 2).collect::<Vec<i32>>();

特殊初始化

// 使用默认值填充
let vec11 = vec![String::new(); 3];  // 3个空字符串

// 使用闭包初始化
let vec12: Vec<i32> = (0..5).map(|i| i * i).collect();

// 复制现有 Vec
let original = vec![1, 2, 3];
let vec13 = original.clone();

不同数据类型

// 字符串 Vec
let strings = vec!["hello", "world"];
let owned_strings = vec![String::from("hello"), String::from("world")];

// 元组 Vec
let tuples = vec![(1, "a"), (2, "b"), (3, "c")];

// 结构体 Vec
#[derive(Clone)]
struct Person { name: String, age: u32 }

let people = vec![
    Person { name: "Alice".to_string(), age: 30 },
    Person { name: "Bob".to_string(), age: 25 },
];

性能提示

• 使用 with_capacity() 预分配已知大小
• vec! 宏在编译时优化
• collect() 适用于函数式编程风格

1. Vec 基础

Vec<T> 是 Rust 标准库中最常用的可增长数组类型，存储在堆上，元素类型为 T。

let mut v: Vec<i32> = Vec::new(); // 创建空 Vec
let v2 = vec![1, 2, 3];           // 使用宏创建

2. 常用操作

添加元素

let mut v = Vec::new();
v.push(10);
v.push(20);

访问元素

let v = vec![1, 2, 3];
println!("{}", v[0]);           // 直接索引（可能 panic）
println!("{:?}", v.get(1));     // get 方法，返回 Option<&T>

遍历

let v = vec![1, 2, 3];
for x in &v {
    println!("{}", x);          // 不可变借用
}
for x in &mut v {
    *x += 1;                    // 可变借用
}
for x in v {
    println!("{}", x);          // 获取所有权，v 被消费
}

3. 其他常用方法

let mut v = vec![1, 2, 3];
v.pop();                        // 移除并返回最后一个元素
v.insert(1, 99);                // 在指定位置插入
v.remove(0);                    // 移除指定位置元素
v.clear();                      // 清空所有元素
v.len();                        // 获取长度
v.is_empty();                   // 是否为空
v.contains(&99);                // 是否包含某值

4. 批量操作

let v = vec![1, 2, 3];
let v2: Vec<_> = v.iter().map(|x| x * 2).collect(); // 映射
let v3: Vec<_> = v.iter().filter(|&&x| x > 1).collect(); // 过滤

5. 与切片的关系

let v = vec![1, 2, 3];
let slice: &[i32] = &v[1..]; // Vec 可以转换为切片

6. 性能和容量

let mut v = Vec::with_capacity(100); // 预分配容量
v.reserve(50);                       // 追加预留
v.shrink_to_fit();                   // 缩减容量

7. 多类型 Vec

enum Value { Int(i32), Text(String) }
let v: Vec<Value> = vec![Value::Int(1), Value::Text("hi".to_string())];

8. 常见错误

• 越界访问会 panic
• 获取所有权后原 Vec 不能再用

9. 实用场景

• 动态收集数据
• 批量处理
• 作为函数参数或返回值

总结

Vec 是 Rust 最常用的动态数组类型，支持高效的插入、删除、遍历和批量操作，适合绝大多数需要动态存储数据的场景。