Rust训练----从零掌握 Rust 集合类型使用技巧

rust// ❌ 每次 push 都可能触发扩容 + 拷贝
let mut v = Vec::new();
for i in 0..10000 {
    v.push(i);
}

// ✅ 提前分配，零额外开销
let mut v = Vec::with_capacity(10000);
for i in 0..10000 {
    v.push(i);
}

rustlet mut v = vec![1, 2, 3];
let more = vec![4, 5, 6];

// ✅ 一次性extend，内部会用 memcpy 优化
v.extend(more);

// ❌ 逐个 push，无法批量优化
for x in more {
    v.push(x);
}

rustlet mut v = vec![1, 2, 3, 4, 5];

// 删除索引 1..3 的元素，并拿到被删除的部分
let drained = v.drain(1..3); 
// v 现在是 [1, 4, 5]
// drained 是 [2, 3]

// 常见用法：批量删除满足条件的元素
v.retain(|&x| x % 2 == 0); // 只保留偶数

rustlet mut map = HashMap::new();
map.insert("key", 42);

// ❌ 如果 key 不存在，直接 panic
let v = map["key"];

// ✅ 用 get，返回 Option
if let Some(&v) = map.get("key") {
    println!("{}", v);
}

// ✅ 用 entry API，原子性地"获取或插入"
let v = map.entry("key").or_insert(0);

rustlet mut map = HashMap::new();
map.insert(1, "a");
map.insert(2, "b");

// ❌ 编译错误：不能同时可变借用和不可变借用
for (k, v) in &map {
    map.remove(&k);
}

// ✅ 方案一：先收集 keys
for k in map.keys().cloned().collect::<Vec<_>>() {
    map.remove(&k);
}

// ✅ 方案二：用 drain（最优雅）
map.drain();

rustlet mut map: HashMap<&str, i32> = HashMap::new();

// 场景1：计数
for word in &["apple", "banana", "apple", "cherry", "banana", "apple"] {
    *map.entry(word).or_insert(0) += 1;
}
// map = {"apple": 3, "banana": 2, "cherry": 1}

// 场景2：只在不存在时插入
map.entry("date").or_insert(1);

// 场景3：修改已存在的值
map.entry("apple").and_modify(|c| *c += 10);

rustuse std::collections::{HashSet, BTreeSet};

let mut hs = HashSet::new();
let mut bs = BTreeSet::new();

for i in [5, 1, 9, 3, 7] {
    hs.insert(i);
    bs.insert(i);
}

// HashSet 遍历顺序不确定
println!("{:?}", hs.iter().collect::<Vec<_>>()); // 可能是 [1, 3, 5, 7, 9] 也可能乱序

// BTreeSet 保证升序
println!("{:?}", bs.iter().collect::<Vec<_>>()); // 一定是 [1, 3, 5, 7, 9]

// 需要范围查询？只能用 BTreeSet
let range: Vec<_> = bs.range(3..=7).copied().collect();
// [3, 5, 7]

rustlet v = vec![1, 2, 3, 4, 5, 6];

// 手动循环
let mut sum = 0;
for &x in &v {
    if x % 2 == 0 {
        sum += x * x;
    }
}

// ✅ 链式迭代器，零中间分配
let sum: i32 = v.iter()
    .filter(|&&x| x % 2 == 0)
    .map(|&x| x * x)
    .sum();

rustlet v = vec!["1", "2", "3"];

// ❌ 编译报错：类型不明确
let nums: Vec<i32> = v.iter().map(|s| s.parse()).collect();

// ✅ turbofish 显式指定
let nums: Vec<i32> = v.iter()
    .map(|s| s.parse().unwrap())
    .collect();

// ✅ 或用 collect 直接推断（更常用）
let nums: Vec<i32> = v.iter()
    .filter_map(|s| s.parse().ok())
    .collect();

rustlet mut v = vec![1, 2, 3, 4, 5, 6];

// filter + collect：分配新 Vec
let evens: Vec<_> = v.iter().filter(|&&x| x % 2 == 0).copied().collect();

// ✅ retain：原地修改，零分配
v.retain(|&x| x % 2 == 0);