迭代器 Iterator Trait
核心概念
Iterator 是 Rust 标准库中定义的核心 trait,用于表示"一系列可以逐个产出的值"。任何实现了 Iterator trait 的类型都可以用 for 循环遍历,也可以使用 map、filter、fold 等丰富的适配器和消费器方法。Iterator trait 只有一个必须实现的方法 next(),它每次调用返回 Some(值) 表示还有元素,返回 None 表示迭代结束。迭代器是惰性的——创建迭代器不会做任何计算,只有调用 next() 或使用消费器方法时才会推进。
fn main() {
let numbers = vec![10, 20, 30, 40, 50];
// 获取迭代器
let mut iter = numbers.iter();
// 手动调用 next()
println!("{:?}", iter.next()); // Some(&10)
println!("{:?}", iter.next()); // Some(&20)
println!("{:?}", iter.next()); // Some(&30)
println!("{:?}", iter.next()); // Some(&40)
println!("{:?}", iter.next()); // Some(&50)
println!("{:?}", iter.next()); // None(迭代完毕)
// for 循环底层就是在调用 next()
for num in numbers.iter() {
print!("{} ", num);
}
println!();
}Iterator trait 的定义
// 标准库中 Iterator trait 的简化版:
// pub trait Iterator {
// type Item; // 关联类型:迭代器产出的元素类型
// fn next(&mut self) -> Option<Self::Item>; // 唯一必须实现的方法
// // ... 下面还有几十个默认方法(map, filter, fold, collect 等)
// }
// 实现 Iterator 只需要定义 Item 类型和 next 方法
struct Countdown {
current: u32,
}
impl Countdown {
fn new(start: u32) -> Self {
Countdown { current: start }
}
}
impl Iterator for Countdown {
type Item = u32; // 产出 u32
fn next(&mut self) -> Option<u32> {
if self.current == 0 {
None // 迭代结束
} else {
let value = self.current;
self.current -= 1;
Some(value)
}
}
}
fn main() {
// 自定义迭代器可以用 for 循环
for n in Countdown::new(5) {
print!("{} ", n);
}
println!();
// 输出: 5 4 3 2 1
// 也可以使用所有迭代器方法
let sum: u32 = Countdown::new(10).sum();
println!("1到10的和: {}", sum);
let evens: Vec<u32> = Countdown::new(10)
.filter(|&n| n % 2 == 0)
.collect();
println!("偶数: {:?}", evens);
}迭代器的惰性特性
fn main() {
let nums = vec![1, 2, 3, 4, 5];
// 这行不会做任何计算——迭代器是惰性的
let iter = nums.iter()
.map(|&x| {
println!(" map: {}", x); // 不会打印
x * 2
})
.filter(|&x| {
println!(" filter: {}", x); // 不会打印
x > 4
});
println!("迭代器已创建,但还没有执行任何计算");
println!("现在开始消费:");
// collect 是消费器,触发实际计算
let result: Vec<i32> = iter.collect();
println!("结果: {:?}", result);
// 注意 map 和 filter 是交替执行的(拉取模式)
// 而不是先 map 全部再 filter 全部
}常用的迭代器方法分类
fn main() {
let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// === 适配器(返回新的迭代器,惰性) ===
// map:转换每个元素
let doubled: Vec<i32> = data.iter().map(|&x| x * 2).collect();
println!("map: {:?}", doubled);
// filter:过滤元素
let evens: Vec<&i32> = data.iter().filter(|&&x| x % 2 == 0).collect();
println!("filter: {:?}", evens);
// take:只取前 N 个
let first_three: Vec<&i32> = data.iter().take(3).collect();
println!("take(3): {:?}", first_three);
// skip:跳过前 N 个
let after_skip: Vec<&i32> = data.iter().skip(7).collect();
println!("skip(7): {:?}", after_skip);
// enumerate:附加索引
for (i, &val) in data.iter().enumerate().take(3) {
println!(" [{}] = {}", i, val);
}
// === 消费器(消耗迭代器,产生最终结果) ===
// sum:求和
let total: i32 = data.iter().sum();
println!("sum: {}", total);
// count:计数
let even_count = data.iter().filter(|&&x| x % 2 == 0).count();
println!("偶数个数: {}", even_count);
// any / all:存在/全部
let has_ten = data.iter().any(|&x| x == 10);
let all_positive = data.iter().all(|&x| x > 0);
println!("有10: {}, 全正: {}", has_ten, all_positive);
// min / max
println!("最小: {:?}, 最大: {:?}", data.iter().min(), data.iter().max());
// fold:自定义累加
let product: i32 = data.iter().take(5).fold(1, |acc, &x| acc * x);
println!("前5个的积: {}", product);
// collect:收集为集合
let set: std::collections::HashSet<&i32> = data.iter().collect();
println!("HashSet 大小: {}", set.len());
}基本示例
实现一个斐波那契迭代器并用丰富的迭代器方法处理:
// 斐波那契数列迭代器
struct Fibonacci {
a: u64,
b: u64,
}
impl Fibonacci {
fn new() -> Self {
Fibonacci { a: 0, b: 1 }
}
}
impl Iterator for Fibonacci {
type Item = u64;
fn next(&mut self) -> Option<u64> {
let value = self.a;
let new_b = self.a + self.b;
self.a = self.b;
self.b = new_b;
Some(value) // 无穷迭代器,永远返回 Some
}
}
fn main() {
// 前 15 个斐波那契数
let fibs: Vec<u64> = Fibonacci::new().take(15).collect();
println!("前15个: {:?}", fibs);
// 斐波那契数中的偶数(前10个)
let even_fibs: Vec<u64> = Fibonacci::new()
.filter(|&n| n % 2 == 0)
.take(10)
.collect();
println!("前10个偶数: {:?}", even_fibs);
// 小于1000的斐波那契数之和
let sum: u64 = Fibonacci::new()
.take_while(|&n| n < 1000)
.sum();
println!("小于1000的总和: {}", sum);
// 带索引的斐波那契数
println!("\n带索引:");
for (i, fib) in Fibonacci::new().take(10).enumerate() {
println!(" F({}) = {}", i, fib);
}
// 相邻斐波那契数的比值趋近黄金比例
println!("\n比值趋近黄金比例:");
let pairs: Vec<(u64, u64)> = Fibonacci::new()
.skip(1) // 跳过第一个 0
.zip(Fibonacci::new().skip(2)) // 配对相邻两个
.take(15)
.collect();
for (a, b) in &pairs {
if *a > 0 {
println!(" {}/{} = {:.10}", b, a, *b as f64 / *a as f64);
}
}
}常见问题
问题一:for 循环和 Iterator 是什么关系?
for item in collection 会先调用 collection.into_iter() 获得迭代器,然后反复调用 next(),直到返回 None。任何实现了 Iterator 或 IntoIterator 的类型都可以用 for 循环。
问题二:适配器和消费器有什么区别?
适配器(map、filter、take 等)返回一个新的迭代器,是惰性的,不会立即执行。消费器(collect、sum、count、for_each 等)消耗迭代器并产生最终结果,会触发实际计算。
问题三:迭代器可以是无穷的吗?
可以。next() 永远返回 Some 就是无穷迭代器。使用时必须用 take、take_while 等方法限制,否则 collect 等消费器会死循环。
问题四:迭代器用完后还能再用吗?
不能。迭代器被消费后(如 collect、for 循环)就被移走了。如果需要多次迭代,要重新创建迭代器,或者在集合上多次调用 .iter()。
适用场景
- 集合遍历:Vec、HashMap、HashSet 等
- 数据处理管道:链式 map、filter、fold
- 无穷序列:数学序列、事件流
- 自定义数据源:文件行、网络数据包
注意事项
- 迭代器是惰性的,必须用消费器触发计算
next()是唯一必须实现的方法- 迭代器被消费后不能重复使用
- 无穷迭代器必须用
take或take_while限制 for循环会自动调用into_iter()和next()- 迭代器链中的适配器是按需拉取的(不是批处理)
总结
Iterator trait 是 Rust 迭代体系的核心,只需实现 next() 方法就能获得几十个默认方法(map、filter、fold、collect 等)。迭代器是惰性的,创建适配器链不会执行计算,只有消费器(collect、sum、for 循环等)才会触发。每次 next() 调用按需产出一个元素,用 Some(值) 表示有数据,None 表示结束。迭代器可以是无穷的,使用 take 等方法限制。自定义迭代器只需定义一个结构体并实现 Iterator trait,就能融入整个迭代器生态。