在 Rust 中，迭代器（Iterator）是一个强大且灵活的工具，用于遍历集合（如数组、向量、哈希表等）。迭代器提供了一种惰性计算的方式，即只有在需要时才会进行计算。以下是对 Rust 迭代器的详细理解：
1. 迭代器基础
迭代器是实现了 Iterator trait 的对象。Iterator trait 定义了一个 next 方法，该方法返回一个 Option 类型，表示迭代器的下一个元素。
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
}Some(value)：表示迭代器的下一个元素。None：表示迭代器已经结束。
2. 创建迭代器
Rust 提供了多种方法来创建迭代器。最常见的是通过集合类型的 iter 方法。
fn main() {
let v = vec![1, 2, 3];
let mut iter = v.iter();
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&3));
assert_eq!(iter.next(), None);
}3. 迭代器适配器
迭代器适配器是对迭代器进行转换的函数，它们返回一个新的迭代器。常见的迭代器适配器包括 map、filter、take 等。
fn main() {
let v = vec![1, 2, 3, 4, 5];
let iter = v.iter().map(|x| x * 2).filter(|x| x > 5);
for val in iter {
println!("{}", val); // 输出 6, 8, 10
}
}4. 消费适配器
消费适配器会消耗迭代器，执行某种操作并返回一个值。常见的消费适配器包括 collect、sum、count 等。
fn main() {
let v = vec![1, 2, 3, 4, 5];
let sum: i32 = v.iter().sum();
println!("Sum: {}", sum); // 输出 Sum: 15
let collected: Vec<i32> = v.iter().map(|x| x * 2).collect();
println!("Collected: {:?}", collected); // 输出 Collected: [2, 4, 6, 8, 10]
}5. 自定义迭代器
你可以通过实现 Iterator trait 来创建自定义迭代器。
struct Counter {
count: u32,
}
impl Counter {
fn new() -> Counter {
Counter { count: 0 }
}
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
self.count += 1;
if self.count <= 5 {
Some(self.count)
} else {
None
}
}
}
fn main() {
let mut counter = Counter::new();
while let Some(value) = counter.next() {
println!("{}", value); // 输出 1, 2, 3, 4, 5
}
}6. 迭代器链
迭代器可以通过链式调用进行组合，形成复杂的数据处理管道。
fn main() {
let v = vec![1, 2, 3, 4, 5];
let result: Vec<i32> = v.iter()
.map(|x| x * 2)
.filter(|x| x > 5)
.collect();
println!("{:?}", result); // 输出 [6, 8, 10]
}7. 惰性计算
迭代器是惰性计算的，这意味着它们不会立即执行，只有在调用消费适配器时才会进行计算。
fn main() {
let v = vec![1, 2, 3, 4, 5];
let iter = v.iter().map(|x| {
println!("Processing: {}", x);
x * 2
});
println!("Before consuming iterator");
let result: Vec<i32> = iter.collect();
println!("After consuming iterator");
println!("{:?}", result); // 输出 [2, 4, 6, 8, 10]
}通过理解这些概念和示例，你可以更好地掌握 Rust 中的迭代器，并利用它们编写高效、简洁的代码。