1. Rust迭代器基础概念
Rust的迭代器是处理集合数据的强大抽象，它提供了一种统一的方式来遍历和操作序列。与C++或Java等语言中的迭代器不同，Rust的迭代器是惰性的(lazy)，这意味着在你明确要求消费(consume)它们之前，它们不会做任何实际工作。
迭代器模式的核心是将数据访问逻辑与数据结构本身分离。在Rust中，几乎所有集合类型（如Vec、HashMap等）都实现了IntoIterator trait，允许它们转换为迭代器。这种设计使得我们可以用相同的方式处理不同类型的数据源。
rust复制let v1 = vec![1, 2, 3];
let v1_iter = v1.iter(); // 创建不可变引用的迭代器
Rust迭代器的一个重要特性是它们实现了Iterator trait，这个trait定义了迭代器的基本行为：
rust复制pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
// 有大量默认实现的方法...
}
2. 迭代器类型与创建方式
2.1 三种基本迭代器类型
Rust中主要有三种迭代器变体，区别在于它们如何处理所有权：
- iter()：产生集合中元素的不可变引用(&T)
- iter_mut()：产生集合中元素的可变引用(&mut T)
- into_iter()：消耗集合并返回元素的所有权(T)
rust复制let mut v = vec!["a".to_string(), "b".to_string()];
// 不可变引用迭代器
for s in v.iter() {
println!("{}", s); // s是&String类型
}
// 可变引用迭代器
for s in v.iter_mut() {
s.push_str("!"); // 可以修改元素
}
// 所有权转移迭代器
for s in v.into_iter() {
println!("{}", s); // s是String类型，v不再可用
}
2.2 常见创建迭代器的方式
除了集合类型自带的迭代器方法，Rust还提供了多种创建迭代器的方式：
- 范围表达式：
(1..10)创建一个1到9的迭代器 - 数组和切片：直接调用
iter()方法 - 标准库函数：
std::iter::empty()：创建空迭代器std::iter::once(value)：创建单元素迭代器std::iter::repeat(value)：创建无限重复的迭代器
rust复制// 范围迭代器
let nums: Vec<_> = (1..5).collect(); // [1, 2, 3, 4]
// 从数组创建
let arr = [1, 2, 3];
let arr_iter = arr.iter();
// 特殊迭代器
let empty = std::iter::empty::<i32>(); // 类型注解是必须的
let one = std::iter::once(42);
let infinite = std::iter::repeat(7);
3. 迭代器适配器与消费者
3.1 迭代器适配器
迭代器适配器是返回新迭代器的方法，允许你对迭代序列进行转换或过滤。常见的适配器包括：
- map：对每个元素应用函数
- filter：保留满足条件的元素
- take/take_while：获取前n个或满足条件的元素
- skip/skip_while：跳过前n个或满足条件的元素
- zip：将两个迭代器组合成对
- chain：连接两个迭代器
- enumerate：添加索引
rust复制let v = vec![1, 2, 3, 4, 5];
// 链式调用适配器
let result: Vec<_> = v.iter()
.map(|x| x * 2) // [2, 4, 6, 8, 10]
.filter(|x| x % 4 == 0) // [4, 8]
.collect();
3.2 迭代器消费者
消费者是消耗迭代器并产生最终结果的操作。常见的消费者包括：
- collect()：将迭代器收集到集合中
- fold()：累积计算
- sum()/product()：求和/求积
- count()：计数
- min()/max()：找最小/最大值
- any()/all()：检查是否存在/所有元素满足条件
- for_each()：对每个元素执行操作
rust复制let numbers = vec![1, 2, 3, 4, 5];
// 求和
let sum: i32 = numbers.iter().sum();
// 折叠操作
let product = numbers.iter().fold(1, |acc, x| acc * x);
// 条件检查
let has_even = numbers.iter().any(|x| x % 2 == 0);
4. 高级迭代器技巧与性能考量
4.1 惰性求值与性能
Rust迭代器的惰性特性使得它们非常高效。考虑以下代码：
rust复制let v = vec![1, 2, 3, 4, 5];
let result = v.iter()
.map(|x| {
println!("processing {}", x);
x * 2
})
.take(2)
.collect::<Vec<_>>();
这里只会打印"processing 1"和"processing 2"，因为take(2)只需要前两个元素，迭代器不会处理后面的元素。
4.2 自定义迭代器
你可以通过实现Iterator trait来创建自定义迭代器：
rust复制struct Counter {
count: u32,
max: u32,
}
impl Counter {
fn new(max: u32) -> Counter {
Counter { count: 0, max }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
if self.count < self.max {
self.count += 1;
Some(self.count)
} else {
None
}
}
}
let counter = Counter::new(5);
for num in counter {
println!("{}", num); // 打印1到5
}
4.3 迭代器与性能优化
Rust的迭代器通常能生成与手写循环一样高效的代码，有时甚至更高效，因为编译器能更好地优化迭代器链。例如：
rust复制// 使用迭代器
let sum: u32 = (1..1000).filter(|x| x % 3 == 0 || x % 5 == 0).sum();
// 等效的手写循环
let mut sum = 0;
for x in 1..1000 {
if x % 3 == 0 || x % 5 == 0 {
sum += x;
}
}
这两种实现通常会编译成几乎相同的机器码，但迭代器版本更简洁且不易出错。
提示：在性能敏感的场景中，使用
iter()而不是into_iter()可以避免元素的所有权转移，通常会有更好的性能表现。
4.4 迭代器与借用检查器
Rust的借用检查器与迭代器配合良好，可以防止常见的迭代时修改集合的错误：
rust复制let mut v = vec![1, 2, 3];
let iter = v.iter();
// 编译错误：不能同时存在可变借用和不可变借用
// v.push(4);
for i in iter {
println!("{}", i);
}
这种保护机制确保了在迭代过程中集合不会被意外修改，避免了潜在的迭代器失效问题。