需求:读一段日志,统计每个级别出现多少次,按次数从多到少排出来。数据量不大,但麻雀虽小:要有容器存日志行,要有表做计数,要有办法排序并取前几名。换别的语言,大概是数组加字典加 sort;Rust 里对应 Vec、HashMap 和迭代器。

真正卡人的不是「有哪几个 API」,而是三件事:为什么 collect 有时候不告诉你结果是什么类型;为什么 for 循环里改 HashMap 会被编译器拦住;为什么 HashMap 打印出来的顺序每次都不一样。这三个问题背后是同一条规则——迭代器持有借用,容器也有所有权。

这篇用一个完整的统计程序把这三件事串起来,顺带把常用的集合操作过一遍。

场景走查:日志统计从零到能跑

先把程序写完,再看每一段为什么这么写。

use std::collections::HashMap;

fn main() {
    let lines = [
        "WARN disk usage 91%",
        "INFO started",
        "WARN disk usage 92%",
        "ERROR db timeout",
        "INFO request ok",
        "WARN cpu 95%",
        "ERROR db timeout",
    ];

    let mut counts: HashMap<&str, u32> = HashMap::new();
    for line in lines {
        let level = line.split_once(' ').unwrap().0;
        *counts.entry(level).or_insert(0) += 1;
    }

    let mut ranked: Vec<(&str, u32)> = counts.into_iter().collect();
    ranked.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(b.0)));

    for (level, n) in &ranked {
        println!("{level}: {n}");
    }

    let total: u32 = ranked.iter().map(|(_, n)| n).sum();
    println!("总计 {total} 条");
}

cargo run 实测输出(排序加了次要条件,保证同次数时顺序稳定):

WARN: 3
ERROR: 2
INFO: 2
总计 7 条

四段代码对应四个动作:用数组装原始行;用 HashMap 计数;转成 Vec 排序;用迭代器求和。下面逐个拆。

统计数据的三次形态变化
原始行 [&str; 7]
计数字典 HashMap
排序列表 Vec
汇总数字 u32

Vec:最常用的容器,先弄清容量和下标

Vec<T> 是堆上的连续数组,三个数字要分清:len() 是当前元素个数,capacity() 是已分配空间能放多少个,is_empty() 判断有没有元素。往满的 Vec 里 push 会触发扩容——重新分配一块更大的内存、把旧元素搬过去。扩容是摊还 O(1),但单次可能是 O(n),对延迟敏感的服务要提前 Vec::with_capacity(n)。

访问元素有两种方式,行为完全不同:

let v = vec![10, 20, 30];

// 1. 下标:越界 panic
let a = v[0];

// 2. get:越界返回 None
if let Some(b) = v.get(1) {
    println!("{b}");
}

用 v[i] 相当于向编译器声明「我保证 i 合法」,判断错了就 panic,前面的文章贴过 index out of bounds 的原文。处理外部输入的下标一律用 get;只在循环 0..v.len() 这种自己能证明范围的地方用下标。

其余常用操作按用途记:push/pop 尾部进出,insert/remove 中间插入删除(O(n),会搬元素),retain 按条件保留,sort 原地排序(要求元素 Ord),sort_by 自定义比较,dedup 去掉相邻重复(要先排序),contains 线性查找。Vec 还实现了 Deref<Target = [T]>,所以切片的方法可以直接在 Vec 上调用,传给 &[T] 参数时也会自动借用成切片。

排序有个容易忽略的细节:sort 是稳定排序,相等元素保持原有相对顺序;sort_unstable 更快、额外内存更少,但不保证相等元素的顺序。按结构体某个字段排序、又希望同字段内保持输入顺序时,用 sort_by_key;只排纯数字、不在乎相等元素时,sort_unstable 更划算。

Vec 里的元素是连续排列的,所以 &v[0] 这类引用会在 push 扩容时失效。这就是上一篇借用规则在集合上的体现:持有元素引用的同时不能往 Vec 里加东西,编译器会拦住。

HashMap:计数的正确姿势是 entry

计数需求最直观的写法是「先查有没有,再加一」:

if let Some(n) = counts.get_mut(level) {
    *n += 1;
} else {
    counts.insert(level, 1);
}

能跑,但要查两次表。entry API 把「查」和「没有就插入」合成一次:

*counts.entry(level).or_insert(0) += 1;

entry(level) 返回一个表示「这个 key 的位置」的枚举,or_insert(0) 在这个位置为空时插入 0,最后返回 &mut V,解引用后加一。除了 or_insert,还有 or_insert_with(|| 复杂计算)(值需要计算时用,避免无谓开销)、or_default()(值实现 Default 时更短)、and_modify(...) 组合已有值。

HashMap 的 key 必须实现 Hash + Eq。用浮点数当 key 会直接报错:

let mut map: HashMap<f64, u32> = HashMap::new();
map.insert(1.5, 1);
error[E0599]: the method `insert` exists for struct `HashMap<f64, u32>`,
but its trait bounds were not satisfied
  |
5 |     map.insert(1.5, 1);
  |         ^^^^^^
  |
  = note: the following trait bounds were not satisfied:
          `f64: Eq`
          `f64: Hash`

人话版:哈希表要按 key 算位置、还要判断「是不是同一个 key」。f64 有 NaN,它连自己都不等于自己,没法满足 Eq;而 Hash 要求相等的值哈希必须相同,NaN 也破坏了这个前提。所以标准库干脆不让它当 key。需要按浮点数分组时,用字符串化的 key、定点整数(比如把 1.5 存成 15),或者按区间分桶。

如果 key 是 String 而不是 &str,entry 还能省一次分配:只有真正要插入时,才需要把构造好的字符串交出去。反过来,一个「查询远多于插入」的表,可以先 get,未命中再走 entry,避免每次查询都为 key 构造一个新 String。这类细节在每请求几十万次的路径上才明显,普通业务先写清楚更重要。

另一个必须知道的特性:HashMap 的遍历顺序是不确定的,而且每次进程启动都可能不同——标准库用了随机种子,防止攻击者构造大量哈希冲突的 key 拖慢服务(哈希 DoS)。所以别写出「依赖 HashMap 顺序」的逻辑。要稳定顺序有两个选择:排序后输出,或者用 BTreeMap(按 key 有序,查找 O(log n))。

迭代器:惰性、链式、要告诉它收集成什么

Rust 的迭代器是惰性的:map、filter 只是包装,不真正遍历,直到遇到消费型方法(collect、sum、count、for 循环)才逐个取值。这个设计让链式调用没有中间集合,一次遍历完成多步处理。

常用组合:

方法作用返回
map把每个元素转换成另一个值迭代器,惰性
filter按谓词保留元素迭代器,惰性
filter_map转换 + 过滤,闭包返回 Option迭代器,惰性
flat_map每个元素展开成多个,再拼接迭代器,惰性
take / skip取前 n 个 / 跳过前 n 个迭代器,惰性
chain接上另一个迭代器迭代器,惰性
collect收集成 Vec、HashMap、String 等目标容器
fold / sum / count / max折叠成单个值具体值或 Option

还有几个不常用、关键时刻能省事的适配器:peekable 可以先看下一个元素再决定要不要消费;切片的 windows(n) 做滑窗,算相邻差值很方便;chunks(n) 按固定大小分批,批量写入时用;zip 把两个迭代器按位置配对,长度不等时以短的为准。这些都是标准库自带,不用自己写工具函数。

collect 是报错高发区,因为它返回的类型由调用方决定,编译器不会猜:

let counts = lines
    .iter()
    .map(|l| l.split_once(' ').unwrap().0)
    .collect();
error[E0283]: type annotations needed
  |
5 |     let counts = lines
  |         ^^^^^^
8 |         .collect();
  |          ------- type must be known at this point
  |
  = note: the type must implement `FromIterator<&str>`
help: consider giving `counts` an explicit type
  |
5 |     let counts: Vec<_> = lines
  |               ++++++++

人话版:Vec 可以、HashSet 可以、HashMap 也可以,甚至 String 在某些元素类型下也可以,编译器不知道你要哪个,只能要求你写清楚。两种写法:给变量加类型标注 let counts: Vec<_> = ...,或者用 turbofish .collect::<Vec<_>>()。写成 HashMap 时元素得是 (K, V) 元组,这也是一种隐式的类型提示。

? 在迭代器闭包里不能直接用——闭包不是函数,返回类型固定,没法「提前返回」。要么在闭包里返回 Option 配合 filter_map,要么用 collect::<Result<Vec<_>, _>>(),它会「遇到第一个 Err 就停」,把一堆 Result 合成一个 Result。后者在处理整批数据时很好用:

let ports: Result<Vec<u16>, _> = raw_lines
    .iter()
    .map(|s| s.trim().parse::<u16>())
    .collect();

遍历时修改容器:为什么被拦,怎么改

统计完想「给每个级别的计数再加一遍上限」,很自然会写出这种代码:

for (k, v) in &map {
    if *v > 0 {
        map.insert("c", 3);
    }
    println!("{k}");
}
error[E0502]: cannot borrow `map` as mutable because it is also
borrowed as immutable
  |
7 |       for (k, v) in &map {
  |       -             ---- immutable borrow occurs here
  |
8 | |         if *v > 0 {
9 | |             map.insert("c", 3);
  | |             ^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
10 | |     }
  | |_____- immutable borrow later used here
  |
  = help: consider using an index-based loop instead, or collecting
    modifications into a separate collection

人话版:&map 已经把所有元素借出去了,遍历期间这些引用还要用;insert 可能触发扩容、重新安排元素位置,让原来的引用全部失效。编译器不允许「一边遍历一边重排」。

此外还有一个更根本的问题:哈希表扩容时,桶的顺序会变,遍历可能重复或漏掉元素。修法按需求分:

  1. 只是改已有 key 的值:用 iter_mut,for (_, v) in map.iter_mut() { *v += 1; },不改结构就安全。
  2. 要增删 key:先把要做的修改收集到 Vec,循环结束后再执行。
  3. 要从 Vec 里删元素:用 retain,一次遍历完成过滤。
  4. 确实需要对每个元素同时改多个位置:Vec 用 split_at_mut,HashMap 只能绕开(remove 后插入,或换 BTreeMap 加别的锁)。

iter、iter_mut、into_iter 三者的区别必须清楚,它决定了你能不能改、原容器还能不能用:

写法元素类型原容器
for x in &v / v.iter()&T还能用,只读
for x in &mut v / v.iter_mut()&mut T还能用,但遍历期间独占
for x in v / v.into_iter()T被消费,之后不能再用

前面统计程序里用的是 counts.into_iter(),因为把字典转成 Vec 之后就不再需要字典本身,正好把所有权交出去,元素类型是 (&str, u32),collect 到 Vec 里不需要拷贝字符串。

返回迭代器:生命周期要写清楚

想把「筛选逻辑」封成函数,返回一个迭代器而不是先 collect 成 Vec,写法是 -> impl Iterator<Item = ...>。只有一个引用参数时,生命周期省略规则会帮你:

fn names(v: &Vec<String>) -> impl Iterator<Item = &String> {
    v.iter()
}

但有两个引用参数时就不行了:

fn pick(a: &Vec<String>, b: &Vec<String>) -> impl Iterator<Item = &String> {
    a.iter().chain(b.iter())
}
error[E0106]: missing lifetime specifier
  |
1 | fn pick(a: &Vec<String>, b: &Vec<String>) -> impl Iterator<Item = &String> {
  |            ------------     ------------             ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the
    signature does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter
  |
1 | fn pick<'a>(a: &'a Vec<String>, b: &'a Vec<String>) -> impl Iterator<Item = &'a String> {
  |        ++++     ++                  ++                          ++

和第三篇里 longest 的报错是同一个:返回值借了谁,签名必须说清楚。这里把两个参数统一成 'a,意思是「返回的迭代器活得不超过两者中较短的那个」,调用方和函数体都按这个约定检查。如果只想借一个,就只给那个参数标生命周期。

另一个选择是不返回迭代器,直接返回 Vec<&String>。多一次分配,但签名简单、生命周期消失。是不是值得,看调用频率和数据量:每请求一次的筛选,先收集通常更省心。

现象对照

现象真实原因第一步查什么
type annotations needed 指向 .collect()目标容器类型无法推断给变量加 Vec<_>/HashMap<_, _>,或用 collect::<...>()
cannot borrow `map` as mutable because it is also borrowed as immutablefor 循环持有整表不可变借用,循环体内又 insert确认要不要改结构;改值用 iter_mut,增删先收集到 Vec
the method `insert` ... trait bounds were not satisfied: `f64: Eq` `f64: Hash`HashMap 的 key 必须 Hash + Eq,浮点不满足换 key 类型:定点整数、字符串、或分桶
missing lifetime specifier 出现在 -> impl Iterator多个引用参数,返回值借谁没写给参数和 Item 加同一个生命周期,或改为返回 Vec
两次运行打印的 key 顺序不同HashMap 使用随机哈希种子,遍历顺序不保证排序后输出,或换 BTreeMap
同样的代码,release 下结果顺序又变同上,且优化/容量变化会改变桶的排布不要依赖 HashMap/HashSet 的顺序做业务逻辑
index out of bounds: the len is 3 but the index is 5下标访问没有边界检查改用 get 返回 Option,或先判断长度
use of moved value: `v` 在 for x in v 之后into_iter 消费了容器改成 &v,或克隆,或调整后续代码不再用 v

边界与代价

第一层代价是 HashMap 的随机顺序。它换来的是抗哈希碰撞攻击的能力,代价是「不能当有序结构用」。需要稳定输出就排序,需要按 key 范围查询就换 BTreeMap,需要保留插入顺序就用 indexmap 这类第三方 crate(不在标准库里)。选容器前先问「我要不要顺序」。

第二层代价是哈希本身的开销。HashMap 默认用 SipHash,抗攻击但比简单哈希慢;热点路径上换更快 hasher(比如 rustc-hash、ahash)能提速,前提是 key 不是外部可控的——如果 key 来自 HTTP 参数,换弱哈希等于给攻击者开门。

第三层是迭代器的可读性权衡。fold 嵌套三层、闭包里再套闭包,比一个普通 for 循环难读得多。迭代器链适合「每一步都很简单」的流水线:过滤、转换、收集。一旦需要在循环里 break、提前返回、记录多个状态,for 循环往往更清楚。这不是风格问题,是维护成本问题。

第四层是中间分配。每条链都 collect 一次,就多一次堆分配和拷贝;一条链里多个 collect,数据翻倍走内存。能一条链走完就别拆,需要复用中间结果时才落地成 Vec。

最后,Vec 的「删除中间元素」是 O(n)。按 id 频繁删除的场景,Vec 不合适:要么用 swap_remove(不保序,O(1)),要么换 HashMap<Id, T>,要么用带空洞标记的数组。数据结构选错,后面所有优化都是在补救。

小结

Vec 管顺序和下标,HashMap 管按 key 查找,BTreeMap 管有序查找。计数用 entry,删元素用 retain,遍历时别改结构。

迭代器是惰性的,collect 必须知道目标类型;iter/iter_mut/into_iter 决定你拿到的是引用还是所有权。返回迭代器时要处理好生命周期,处理不好就先收集成 Vec。

当天可以自己验证的练习:

  1. 把统计程序改成「取前 3 名」,用 ranked.iter().take(3) 输出,观察 take 不产生新 Vec。
  2. 把 HashMap 换成 BTreeMap,去掉 sort_by,确认输出按 key 字母序。
  3. 故意写 let counts = ...collect(); 不标类型,读一遍 E0283,再用两种写法修好。
  4. 用 collect::<Result<Vec<u16>, _>>() 把一组字符串转成端口号,其中一个故意写 "abc",确认整体返回 Err。
  5. 在 for (k, v) in &map 里尝试 remove,把报错和这篇文章的对照表对一遍,再改成先收集后删除。

下一篇讲模块、crate 与 workspace。这一篇所有代码都在一个 main.rs 里,几十行还能忍;真实项目要拆成统计、配置、输出几块,还要能被别的 crate 复用。模块怎么划、pub 到哪一层、workspace 怎么组织多个二进制,是下一篇的内容。