消费适配器

> 掌握迭代器的消费方法，学会使用 collect、fold、sum 等方法收集和计算结果。

消费适配器（Consuming Adapters）

什么是消费适配器

消费适配器会消耗迭代器并产生结果。
调用后，原迭代器不能再使用。

常见的消费适配器：
• sum() - 求和
• count() - 计数
• collect() - 收集到集合
• fold() - 累积折叠
• for_each() - 对每个元素执行操作

sum 和 count

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // sum - 求和
    let sum: i32 = numbers.iter().sum();
    println!("总和：{}", sum);  // 15

    // 也可以用于其他数值类型
    let sum_f64: f64 = numbers.iter().map(|&x| x as f64).sum();
    println!("f64 总和：{}", sum_f64);

    // count - 计数
    let count = numbers.iter().count();
    println!("数量：{}", count);  // 5

    // 统计偶数个数
    let even_count = numbers.iter().filter(|&&x| x % 2 == 0).count();
    println!("偶数个数：{}", even_count);  // 2
}

▶ Run

collect

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // collect 到 Vec
    let doubled: Vec<i32> = numbers
        .iter()
        .map(|x| x * 2)
        .collect();
    println!("翻倍：{:?}", doubled);

    // collect 到其他类型（需要类型标注）
    let doubled_set: std::collections::HashSet<_> = numbers
        .iter()
        .map(|x| x * 2)
        .collect();
    println!("HashSet: {:?}", doubled_set);

    // collect 成 String
    let chars = vec!['H', 'e', 'l', 'l', 'o'];
    let greeting: String = chars.into_iter().collect();
    println!("String: {}", greeting);

    // collect Result（遇到第一个 Err 就返回）
    let results = vec![Ok(1), Ok(2), Ok(3)];
    let result: Result<Vec<_>, _> = results.into_iter().collect();
    println!("Result: {:?}", result);  // Ok([1, 2, 3])

    // collect Option（遇到第一个 None 就返回）
    let options = vec![Some(1), Some(2), None];
    let result: Option<Vec<_>> = options.into_iter().collect();
    println!("Option: {:?}", result);  // None
}

▶ Run

fold（折叠/累积）

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // fold - 累积操作
    // fold(初始值，闭包(累积值，当前元素))
    let sum: i32 = numbers.iter().fold(0, |acc, x| acc + x);
    println!("总和：{}", sum);  // 15

    // 乘积
    let product: i32 = numbers.iter().fold(1, |acc, x| acc * x);
    println!("乘积：{}", product);  // 120

    // 累积为字符串
    let words = vec!["Hello", " ", "World", "!"];
    let sentence: String = words
        .iter()
        .fold(String::new(), |acc, word| acc + word);
    println!("句子：{}", sentence);

    // 使用 fold 同时跟踪多个状态
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let (sum, product) = numbers.iter().fold((0, 1), |(sum, prod), &x| {
        (sum + x, prod * x)
    });
    println!("总和：{}, 乘积：{}", sum, product);
}

▶ Run

for_each

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // for_each - 对每个元素执行操作
    print!("数字：");
    numbers.iter().for_each(|x| print!(" {} ", x));
    println!();

    // 使用外部变量
    let mut sum = 0;
    numbers.iter().for_each(|x| {
        sum += x;
    });
    println!("总和：{}", sum);
}




---

## 小结

- 消费适配器消耗迭代器并产生结果
- sum、count、collect 是最常用的消费方法
- fold 可以累积任意复杂的状态
- collect 可以收集到多种类型：Vec、HashSet、String
- for_each 对每个元素执行操作，不返回值

## 练习题

详见：[练习题](../../exercises/19-iterators)

▶ Run