Rust_iter

迭代器

什么是迭代器？

• 迭代器是rust用于遍历集合的一种抽象，提供了一种统一的方式来访问集合中的元素，而不需要关心集合的具体实现
• rust的迭代器是惰性的，只会在真正需要时才回进行计算

迭代器的核心trait：Iterator

Iterator trait的定义：

pub trait Iterator{
	type Item;//迭代器产生的值的类型
	fn next(&mut self)->Option<Self::Item>;//获取下一个元素 
}

创建迭代器：

• iter()：生成一个不可变引用的迭代器。
• iter_mut()：生成一个可变引用的迭代器。
• into_iter()：生成一个获取所有权的迭代器。

使用迭代器：

常用的方法：

1. map ：对每个元素进行转换

fn map<B, F>(self, f: F) -> Map<Self, F>
where
    F: FnMut(Self::Item) -> B,

map方法接受一个闭包f，该闭包会对迭代器中的每个元素进行转换， 返回一个新的迭代器 ，产生转换后的值

【例子】

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

• 由于返回的是一个迭代器，需要使用 collect() 方法来将迭代器转换成集合
• Vec<_>：_ 是一个占位符，表示让 Rust 编译器推断集合的类型。

1. filter ：过滤元素

   fn filter<P>(self, predicate: P) -> Filter<Self, P>
   where
       P: FnMut(&Self::Item) -> bool,

   filter方法接受一个闭包，该闭包会对每个元素进行判断，如果闭包返回true，则保留，否则丢弃；

   返回一个新的得带起，只包含满足闭包的元素

   【例子】

   let v = vec![1, 2, 3, 4];
   let evens: Vec<_> = v.iter().filter(|&x| x % 2 == 0).collect();
   println!("{:?}", evens); // 输出 [2, 4]

2. fold ：累积计算

   fn fold<B, F>(self, init: B, f: F) -> B
   where
       F: FnMut(B, Self::Item) -> B,

   fold方法接受一个初始值init和一个闭包f；闭包会对每个元素进行累积计算；返回最终的累积结果

   【例子】

   let v = vec![1, 2, 3];
   let sum: i32 = v.iter().fold(0, |acc, &x| acc + x);
   println!("{}", sum); // 输出 6

3. collect ：将迭代器转换为集合

   fn collect<B>(self) -> B
   where
       B: FromIterator<Self::Item>,

   【例子】

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

4. enumerate ：获取索引和值
   【例子】

   let v = vec!['a', 'b', 'c'];
   for (index, value) in v.iter().enumerate() {
       println!("{}: {}", index, value);
   }
   // 输出：
   // 0: a
   // 1: b
   // 2: c