Rust 迭代器

迭代器是 Rust 中用于遍历集合的强大工具。本章节将介绍 Rust 中的迭代器。

迭代器基础

迭代器是实现了 Iterator trait 的类型，它提供了 next 方法来逐个获取元素：

fn main() {
    let v = vec![1, 2, 3];
    let mut iter = v.iter();
    
    println!("{:?}", iter.next()); // Some(1)
    println!("{:?}", iter.next()); // Some(2)
    println!("{:?}", iter.next()); // Some(3)
    println!("{:?}", iter.next()); // None
}

迭代器的类型

Rust 中有三种主要的迭代器类型：

1. 不可变引用迭代器：iter() 方法返回
2. 可变引用迭代器：iter_mut() 方法返回
3. 所有权迭代器：into_iter() 方法返回

fn main() {
    let v = vec![1, 2, 3];
    
    // 不可变引用迭代器
    println!("Immutable iterator:");
    for i in v.iter() {
        println!("{}", i);
    }
    
    // 可变引用迭代器
    println!("Mutable iterator:");
    let mut v2 = vec![1, 2, 3];
    for i in v2.iter_mut() {
        *i *= 2;
        println!("{}", i);
    }
    
    // 所有权迭代器
    println!("Into iterator:");
    for i in v.into_iter() {
        println!("{}", i);
    }
    // v 已经被消费，不能再使用
}

迭代器适配器

迭代器适配器用于转换迭代器：

map

map 方法将迭代器中的每个元素转换为新的元素：

fn main() {
    let v = vec![1, 2, 3];
    let doubled: Vec<_> = v.iter().map(|&x| x * 2).collect();
    println!("Doubled: {:?}", doubled);
}

filter

filter 方法根据条件过滤元素：

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let even: Vec<_> = v.iter().filter(|&&x| x % 2 == 0).collect();
    println!("Even: {:?}", even);
}

take

take 方法获取前 n 个元素：

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let first_three: Vec<_> = v.iter().take(3).collect();
    println!("First three: {:?}", first_three);
}

skip

skip 方法跳过前 n 个元素：

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let after_three: Vec<_> = v.iter().skip(3).collect();
    println!("After three: {:?}", after_three);
}

chain

chain 方法连接两个迭代器：

fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = vec![4, 5, 6];
    let combined: Vec<_> = v1.iter().chain(v2.iter()).collect();
    println!("Combined: {:?}", combined);
}

zip

zip 方法将两个迭代器的元素配对：

fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = vec![4, 5, 6];
    let zipped: Vec<_> = v1.iter().zip(v2.iter()).collect();
    println!("Zipped: {:?}", zipped);
}

迭代器消费者

迭代器消费者是使用迭代器并产生结果的方法：

collect

collect 方法将迭代器的结果收集到集合中：

fn main() {
    let v = vec![1, 2, 3];
    let doubled: Vec<_> = v.iter().map(|&x| x * 2).collect();
    println!("Doubled: {:?}", doubled);
    
    let doubled_hash_set: std::collections::HashSet<_> = v.iter().map(|&x| x * 2).collect();
    println!("Doubled hash set: {:?}", doubled_hash_set);
}

sum

sum 方法计算迭代器元素的和：

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let sum: i32 = v.iter().sum();
    println!("Sum: {}", sum);
}

product

product 方法计算迭代器元素的积：

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let product: i32 = v.iter().product();
    println!("Product: {}", product);
}

max 和 min

max 和 min 方法返回迭代器中的最大值和最小值：

fn main() {
    let v = vec![3, 1, 4, 1, 5, 9, 2, 6];
    let max = v.iter().max();
    let min = v.iter().min();
    println!("Max: {:?}, Min: {:?}", max, min);
}

count

count 方法计算迭代器中的元素个数：

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let count = v.iter().count();
    println!("Count: {}", count);
}

自定义迭代器

可以实现 Iterator trait 来创建自定义迭代器：

struct Counter {
    count: u32,
    max: u32,
}

impl Counter {
    fn new(max: u32) -> Self {
        Counter { count: 0, max }
    }
}

impl Iterator for Counter {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count <= self.max {
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let counter = Counter::new(5);
    for i in counter {
        println!("{}", i);
    }
}

总结

• 迭代器：实现了 Iterator trait 的类型
• 迭代器类型：不可变引用、可变引用、所有权
• 迭代器适配器：map、filter、take、skip 等
• 迭代器消费者：collect、sum、product、max、min 等
• 自定义迭代器：实现 Iterator trait

迭代器是 Rust 中非常强大的工具，它提供了一种统一的方式来遍历集合。通过本章节的学习，你应该已经掌握了 Rust 中迭代器的使用方法。