一篇文章掌握Rust迭代器的用法

Rust 迭代器的核心思想是：把“遍历、转换、筛选、汇总”组合成一条清晰的数据处理流水线。

1. 三个基本概念

collection.iter()

创建迭代器。迭代器通常是惰性的，调用它本身不会立即执行。

.map(...)
.filter(...)

对元素进行转换或筛选。

.collect()
.count()
.sum()
.product()

消费迭代器，真正执行整个流程。

例如：

let numbers = vec![1, 2, 3, 4, 5];

let result: Vec<i32> = numbers
    .iter()
    .map(|n| n * 2)
    .filter(|n| *n > 5)
    .collect();

结果：

[6, 8, 10]

2. 常用适配器

map：转换元素

let squares: Vec<_> = (1..=5)
    .map(|x| x * x)
    .collect();

filter：筛选元素

let even_numbers: Vec<_> = (1..=10)
    .filter(|x| x % 2 == 0)
    .collect();

flat_map：展开嵌套结构

let nested = vec![vec![1, 2], vec![3, 4]];

let result: Vec<_> = nested
    .into_iter()
    .flat_map(|v| v)
    .collect();

enumerate：同时获得索引

for (index, value) in items.iter().enumerate() {
    println!("{index}: {value}");
}

zip：合并两个迭代器

let names = vec!["Alice", "Bob"];
let scores = vec![90, 80];

for (name, score) in names.iter().zip(scores.iter()) {
    println!("{name}: {score}");
}

3. 常用终结操作

判断是否存在：

let has_even = numbers.iter().any(|x| x % 2 == 0);

判断是否全部满足：

let all_positive = numbers.iter().all(|x| *x > 0);

查找元素：

let found = numbers.iter().find(|x| **x == 3);

求和、乘积：

let sum: i32 = (1..=5).sum();
let product: i32 = (1..=5).product();

自定义累积：

let sum = numbers.iter().fold(0, |total, x| total + x);

fold 可以理解为：从初始值开始，逐个处理元素，并不断更新结果。

4. 理解 `iter`、`iter_mut` 和 `into_iter`

items.iter()

借用元素，不会取得所有权。

items.iter_mut()

可以修改元素，但仍然不取得容器所有权。

items.into_iter()

取得元素所有权，原集合通常不能再使用。

let words = vec!["hello".to_string(), "rust".to_string()];

for word in words.into_iter() {
    println!("{word}");
}

// words 之后不能再使用

选择原则：

只读：iter()
修改：iter_mut()
消费并取得所有权：into_iter()

5. `collect` 时通常需要指定类型

let result: Vec<i32> = numbers
    .iter()
    .map(|x| x * 2)
    .collect();

也可以使用 turbofish 语法：

let result = numbers
    .iter()
    .map(|x| x * 2)
    .collect::<Vec<_>>();

6. 你给出的代码可以这样理解

collection
    .iter()
    .flat_map(|map| map.values())
    .filter(|&val| *val == value)
    .count()

它是一条流水线：

多个 HashMap
    ↓
每个 HashMap 的 values
    ↓
合并成一个值序列
    ↓
筛选等于 value 的元素
    ↓
统计数量

7. 使用迭代器的建议

可以按这个顺序思考：

我要遍历什么？——iter
我要不要转换？——map
我要不要展开嵌套结构？——flat_map
我要筛选什么？——filter
最终结果是什么？——count、collect、sum、fold 等

不要为了“看起来函数式”而强行使用迭代器。如果逻辑复杂，普通 for 循环往往更易读。好的 Rust 代码不是链式调用越长越好，而是让数据处理过程清楚。