迭代器 Iterator Trait ​

核心概念 ​

Iterator 是 Rust 标准库中定义的核心 trait,用于表示"一系列可以逐个产出的值"。任何实现了 Iterator trait 的类型都可以用 for 循环遍历,也可以使用 map、filter、fold 等丰富的适配器和消费器方法。Iterator trait 只有一个必须实现的方法 next(),它每次调用返回 Some(值) 表示还有元素,返回 None 表示迭代结束。迭代器是惰性的——创建迭代器不会做任何计算,只有调用 next() 或使用消费器方法时才会推进。

rust
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 的定义 ​

rust
// 标准库中 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);
}

迭代器的惰性特性 ​

rust
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 全部
}

常用的迭代器方法分类 ​

rust
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());
}

基本示例 ​

实现一个斐波那契迭代器并用丰富的迭代器方法处理:

rust
// 斐波那契数列迭代器
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,就能融入整个迭代器生态。