## 迭代器概念 **迭代器** [`iterator`](https://doc.rust-lang.org/std/iter/)负责遍历序列中的每一项和决定序列何时结束的逻辑 ## 迭代形式有三种常用方法可以从集合中创建迭代器： - `iter()` 对`&T` 进行遍历 - `iter_mut()` 对 `&mut T` 进行迭代 - `into_iter()` 对 `T` 进行迭代 > [`into_iter()`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html#tymethod.into_iter "method std::iter::IntoIterator::into_iter")以`self`为值，因此使用`for`循环遍历集合会消耗该集合 > `iter()`和`iter_mut()` 能在不消耗集合的情况下遍历集合 ## EG ```rust let v1 = vec![1, 2, 3]; let v1_iter = v1.iter(); ``` ## 核心trait ### Iterator #### 说明 ```rust trait Iterator { type Item; fn next(&mut self) -> Option; } ``` 迭代器有一个方法[`next`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next "method std::iter::Iterator::next")，调用它时会返回一个[`Option`](https://doc.rust-lang.org/std/option/enum.Option.html "enum std::option::Option")。只要有元素，调用[`next`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next "method std::iter::Iterator::next")就会返回[`Some(Item)`](https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some "variant std::option::Option::Some")，一旦元素全部迭代完成，就会返回`None`，表示迭代结束。 > 单个迭代器可以选择恢复迭代，因此再次调用[`next`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next "method std::iter::Iterator::next")可能会也可能不会最终在某个时刻再次返回[`Some(Item)`](https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some "variant std::option::Option::Some")（例如，请参阅[`TryIter`](https://doc.rust-lang.org/std/sync/mpsc/struct.TryIter.html)）。 ## 实现自己的迭代器 ### 说明创建一个自己的迭代器涉及两个步骤： - 创建一个 **结构体** 用于**保存迭代器的状态** - 为该 **结构体** 实现 [**`Iterator`**](https://doc.rust-lang.org/std/iter/trait.Iterator.html "trait std::iter::Iterator") ### EG ```rust // 定义一个结构体 struct Counter { count: usize, } // 为这个结构体实现new方法，该方法用于创建一个初始化对象 impl Counter { fn new() -> Counter { Counter { count: 0 } } } // 为该结构体实现 `Iterator` trait，且必须实现next方法 impl Iterator for Counter { type Item = usize; // next() is the only required method fn next(&mut self) -> Option { self.count += 1; if self.count < 6 { Some(self.count) } else { None } } } let mut counter = Counter::new(); assert_eq!(counter.next(), Some(1)); assert_eq!(counter.next(), Some(2)); assert_eq!(counter.next(), Some(3)); assert_eq!(counter.next(), Some(4)); assert_eq!(counter.next(), Some(5)); assert_eq!(counter.next(), None); ``` ## 和for循环的关系 ### 说明 `Rust` 的 `for` 循环语法实际上是迭代器的糖 ```rust let values = vec![1, 2, 3, 4, 5]; for x in values { println!("{x}"); } ``` 在标准库中，有一种特性可以将某些东西转换成迭代器：[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html "trait std::iter::IntoIterator")。该特质有一个方法，即[`into_iter`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html#tymethod.into_iter "method std::iter::IntoIterator::into_iter")，用于将实现[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html "trait std::iter::IntoIterator")的事物转换为迭代器。 ```rust let values = vec![1, 2, 3, 4, 5]; { let result = match IntoIterator::into_iter(values) { mut iter => loop { let next; match iter.next() { Some(val) => next = val, None => break, }; let x = next; let () = { println!("{x}"); }; }, }; result } ``` 如果集合类型`C`提供`iter()`，它通常也会为`&C` 实现`IntoIterator`，其实现方式只是调用`iter()`。同样，提供`iter_mut()`的集合`C`通常通过委托`iter` `_mut`()来实现`&mut C`的`IntoIterator` ## 适配器 ### 说明接收一个[`迭代器`](https://doc.rust-lang.org/std/iter/trait.Iterator.html "trait std::iter::Iterator")并返回另一个[`迭代器`](https://doc.rust-lang.org/std/iter/trait.Iterator.html "trait std::iter::Iterator")的函数通常被称为 "迭代器适配器"，因为它们是 "适配器模式 "的一种形式 ### 常见迭代器适配器 | 方法名 | 返回类型 | 功能说明 | | ---------------- | ----------- | ------------------------- | | `.map(f)` | `Map` | 映射每个元素为另一个值 | | `.filter(f)` | `Filter` | 保留满足条件的元素 | | `.filter_map(f)` | `FilterMap` | 同时过滤并转换元素 | | `.enumerate()` | `Enumerate` | 元素包装为 `(index, value)` 元组 | | `.skip(n)` | `Skip` | 跳过前 `n` 个元素 | | `.take(n)` | `Take` | 仅取前 `n` 个元素 | | `.chain(iter)` | `Chain` | 拼接两个迭代器 | | `.zip(iter)` | `Zip` | 配对两个迭代器中的元素 | | `.peekable()` | `Peekable` | 可查看下一个元素而不消费 | | `.rev()` | `Rev` | 反转顺序（必须是双端迭代器） | | `.inspect(f)` | `Inspect` | 每个元素执行副作用（常用于调试） | ### `map` #### 说明 [`map`](`https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map`) 对迭代器的每个元素应用一个闭包，并返回一个包含这些结果的新迭代器。此函数是`lazy`的，只有在“消费”这个迭代器（如 `.next()` 或 `.collect()`）时，才会触发`map`内的闭包函数 > 使用场景：对集合中的每个元素进行转换 ```rust fn map(self, f: F) -> Map where Self: Sized, F: FnMut(Self::Item) -> B, ``` #### EG ```rust fn main() { let nums = [1, 2, 3]; let mut mapped = nums.iter().map(|x| { println!("mapping: {}", x); x * 2 }); println!("nums {:#?}", nums); println!("use mapped {:#?}", mapped.next()); // 注释掉此行后，map是懒惰的，其内部闭包函数不会执行 } /* nums [ 1, 2, 3, ] mapping: 1 use mapped Some( 2, ) */ ``` ### `filter` #### 说明 [`filter`](`https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter `) 创建一个迭代器，它只包含通过指定条件的元素。闭包必须返回`true`或`false`。返回的迭代器将仅产生闭包返回 `true` 的元素 > 使用场景：从集合中过滤出符合条件的元素 ```rust fn filter

(self, predicate: P) -> Filter where Self: Sized, P: FnMut(&Self::Item) -> bool ``` #### EG ```rust fn main() { let numbers = vec![1, 2, 3, 4, 5]; // 3. 使用 filter 过滤掉偶数 let odd_numbers: Vec = numbers.iter().filter(|&&x| x % 2 != 0).cloned().collect(); println!("Odd numbers: {:?}", odd_numbers); } // Odd numbers: [1, 3, 5] ``` ### `filter_map` #### 说明 [`filter`](`https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map`) 创建一个迭代器，它只包含所提供的闭包函数返回 `Some(value)` 的值。`filter_map` 可用于使 `filter` 和 `map` 链更简洁。此函数是`lazy`的，只有在“消费”这个迭代器（如 `.next()` 或 `.collect()`）时，才能得到最终结果 > 使用场景：从集合中过滤出符合条件的元素并进行转换 ```rust fn filter_map(self, f: F) -> FilterMap where Self: Sized, F: FnMut(Self::Item) -> Option, ``` #### EG ```rust fn main() { let items = vec!["42", "foo", "100", "bar"]; let parsed = items .into_iter() .filter_map(|s| s.parse::().ok()); println!("is lazy do not use next {:?}", parsed); /* println!("{:?}", parsed.next()); // Some(42) println!("{:?}", parsed.next()); // Some(100) println!("{:?}", parsed.next()); // None 已经被消费完了 println!("{:?}", parsed.next()); // None 已经被消费完了 */ println!("collect {:?}", parsed.collect::>()); } /* is lazy do not use next FilterMap { iter: IntoIter(["42", "foo", "100", "bar"]) } // 内部还未消费的原始数据结构 collect [42, 100] */ ``` ### `enumerate` #### 说明 [`enumerate`]("https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.enumerate") 创建一个迭代器，迭代器的 `Item` 类型是 `(usize, T)`，即：`(索引，原始元素)` ```rust fn enumerate(self) -> Enumerate where Self: Sized, ``` #### EG ```rust fn main() { let items = vec!["apple", "banana", "cherry"]; for (i, item) in items.iter().enumerate() { println!("Index: {}, Item: {}", i, item); } } /* Index: 0, Item: apple Index: 1, Item: banana Index: 2, Item: cherry */ ``` ### `skip` #### 说明 [`skip`](`https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.skip`) 创建一个迭代器，跳过原迭代器前`n`个元素 ```rust fn skip(self, n: usize) -> Skip where Self: Sized, ``` #### EG ```rust fn main() { let a = [1, 2, 3]; let mut iter = a.iter().skip(2); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); } /* Some(3) None None */ ``` ### `take` #### 说明 [`take`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.take) 创建一个迭代器，它只生成原始迭代器前 `n` 个元素 > 使用场景：限制结果集的大小 ```rust fn take(self, n: usize) -> Take where Self: Sized, ``` #### EG ```rust fn main() { let a = [1, 2, 3]; let mut iter = a.iter().take(2); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); } /* Some(1) Some(2) None */ ``` ### `chain` #### 说明 [`chain`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain) 将两个迭代器链接为一个新迭代器，同样是 `lazy` ```rust fn chain(self, other: U) -> Chain::IntoIter> where Self: Sized, U: IntoIterator, ``` #### EG ```rust fn main() { let a1 = [1, 2, 3]; let a2 = [4, 5, 6]; let mut iter = a1.iter().chain(a2.iter()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); } /* Some(1) Some(2) Some(3) Some(4) Some(5) Some(6) None */ ``` ### `zip` #### 说明 [`zip`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.zip) 将两个迭代器的元素配链接后创建了一个新的迭代器，生成的每个元素都是一个元组，包含来自两个输入迭代器的对应元素，其中第一个元素来自第一个迭代器，第二个元素来自第二个迭代器。 > 会在最短的迭代器结束时停止，即截断长的那一方 ```rust fn zip(self, other: U) -> Zip::IntoIter> where Self: Sized, U: IntoIterator, ``` #### EG ```rust fn main() { let a1 = [1, 2, 3]; let a2 = [4, 5, 6]; let mut iter = a1.iter().zip(a2.iter()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); println!("{:?}", iter.next()); } /* Some((1, 4)) Some((2, 5)) Some((3, 6)) None */ ``` ### `peekable` #### 说明 [`peekable`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.peekable) 创建一个迭代器，该迭代器可以使用 `peek` 和 `peek_mut` 方法查看迭代器的下一个元素，而无需消耗迭代器 ```rust fn peekable(self) -> Peekable where Self: Sized, ``` |方法|说明| |---|---| |`.peek()`|返回 `Option<&T>`，可以查看但不消费| |`.next()`|还是照常消费| #### EG ```rust fn main() { let mut iter = [1, 2, 3].iter().peekable(); while let Some(&val) = iter.peek() { println!("Peeking: {val}"); println!("Next: {:?}", iter.next()); } } /* Peeking: 1 Next: Some(1) Peeking: 2 Next: Some(2) Peeking: 3 Next: Some(3) */ ``` ### `rev` #### 说明 [`rev`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.rev) 反转迭代器的顺序，从后往前遍历 > 只能用于实现了 `DoubleEndedIterator` 的类型（如 `Vec`, `Array` 等） ```rust fn rev(self) -> Rev where Self: Sized + DoubleEndedIterator, ``` #### EG ```rust fn main() { let v = vec![1, 2, 3]; for x in v.iter().rev() { println!("{x}"); } } /* 3 2 1 */ ``` ### `inspect` #### 说明 [`inspect`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.inspect) 在遍历过程中执行副作用操作，如中间打印或执行一些副作用操作，不影响结果。 > 通常用于调试 ```rust fn inspect(self, f: F) -> Inspect where Self: Sized, F: FnMut(&Self::Item), ``` #### EG ```rust fn main() { let result: Vec<_> = (1..5) .inspect(|x| println!("Before map: {x}")) .map(|x| x * 2) .inspect(|x| println!("After map: {x}")) .collect(); println!("{:?}", result); } /* Before map: 1 After map: 2 Before map: 2 After map: 4 Before map: 3 After map: 6 Before map: 4 After map: 8 [2, 4, 6, 8] */ ``` ### for_each ### 说明 [`for_each`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.for_each) 对每个元素应用一个闭包，但不会返回新的迭代器 > 使用场景：对集合中的每个元素执行操作但不需要结果 #### EG ```rust fn main(){ let numbers = vec![1, 2, 3, 4, 5]; // 4. 使用 for_each 打印每个元素 numbers.iter().for_each(|&x| println!("Number: {}", x)); } ``` ## Laziness懒惰 ### 说明在 `Rust` 中，迭代器和迭代适配器都是是 **惰性的**（`lazy`），这意味着在调用方法（`next()等`）使用迭代器之前它都不会有效 ### EG ```rust let v = vec![1, 2, 3, 4, 5]; v.iter().map(|x| println!("{x}")); ``` 此时`rust`编译器会发出警告 ```rust warning: unused result that must be used: iterators are lazy and do nothing unless consumed ``` 需要使用`for_each`或`for`来解决 ```rust let v = vec![1, 2, 3, 4, 5]; v.iter().for_each(|x| println!("{x}")); // or for x in &v { println!("{x}"); } ``` 也可以使用`collect`方法生成一个新的集合 > collect方法：只要目标类型实现了 `FromIterator trait` ，`collect` 方法是迭代器（`Iterator`）常用的工具之一，可用于将迭代器转换成集合，如向量（`Vec`）、哈希集合（`HashSet`）、字符串（`String`）等 #### EG ```rust // 转换为vec fn main() { let vec = vec![1, 2, 3, 4, 5]; let collected: Vec<_> = vec.iter().map(|&x| x * 2).collect(); println!("{:?}", collected); // 输出: [2, 4, 6, 8, 10] } // 转换为String fn main() { let chars = vec!['h', 'e', 'l', 'l', 'o']; let collected: String = chars.into_iter().collect(); println!("{}", collected); // 输出: hello } // 转为HashSet use std::collections::HashSet; fn main() { let vec = vec![1, 2, 2, 3, 4, 4, 5]; let collected: HashSet<_> = vec.iter().cloned().collect(); println!("{:?}", collected); // 输出: {1, 2, 3, 4, 5} } // 转为HashMap use std::collections::HashMap; fn main() { let keys = vec!["a", "b", "c"]; let values = vec![1, 2, 3]; let collected: HashMap<_, _> = keys.into_iter().zip(values.into_iter()).collect(); println!("{:?}", collected); // 输出: {"a": 1, "b": 2, "c": 3} } ``` ## 无限迭代 ### 说明对于无限迭代的情况，通常需要使用`take`迭代适配器将其转换为有限。 > 无限迭代器上的方法，即使是那些可以在有限时间内用数学方法确定结果的方法，也可能无法终止。具体来说，像[`min`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.min "method std::iter::Iterator::min") 这样的方法，在一般情况下需要遍历迭代器中的每个元素，对于任何无限迭代器来说，都可能无法成功返回结果 ### EG ```rust let numbers = 0..; let five_numbers = numbers.take(5); for number in five_numbers { println!("{number}"); } ``` ## 终结方法 |方法名|返回类型|功能说明| |---|---|---| |`.collect()`|`Collection`|收集为 `Vec` / `String` / `HashMap` 等| |`.sum()`|`T`|所有元素求和（要求 `T: Sum`）| |`.product()`|`T`|所有元素连乘（要求 `T: Product`）| |`.count()`|`usize`|元素个数| |`.fold(init, f)`|`T`|从初始值起归约元素| |`.reduce(f)`|`Option`|无初始值的归约操作| |`.all(f)`|`bool`|所有元素都满足条件时返回 `true`| |`.any(f)`|`bool`|任意一个元素满足条件即返回 `true`| |`.find(f)`|`Option`|返回第一个满足条件的元素| |`.position(f)`|`Option`|返回第一个满足条件的元素索引| |`.max()`|`Option`|返回最大值| |`.min()`|`Option`|返回最小值| |`.last()`|`Option`|返回最后一个元素| ### `collect` #### 说明将迭代器中所有元素“收集”到集合中，如 `Vec`、`String`、`HashMap` 等。该方法会消耗迭代器。此方法非常通用，会导致类型推断问题则可以手动通过`::<>`指定具体类型 ```rust fn collect(self) -> B where B: FromIterator, Self: Sized, ``` #### EG ```rust fn main() { let a = [1, 2, 3]; let doubled = a.iter().map(|x| x * 2).collect::>(); println!("{:?}", doubled); let chars = ['g', 'd', 'k', 'k', 'n']; let hello: String = chars.iter() .map(|&x| x as u8) .map(|x| (x + 1) as char) .collect(); println!("{:?}", hello); } /* [2, 4, 6] "hello" */ ``` ### `sum` #### 说明对迭代器中的元素求和。取每个元素相加，然后返回结果。`sum() `可用于对任何实现 `Sum` 的类型求和，包括 `Option` 和 `Result`。 > 空迭代器：整数为 `0`，浮点数为` -0.0` > 当返回原始整数类型时，如果计算溢出和调试断言已启用，此方法就会`panic` ```rust fn sum(self) -> S where Self: Sized, S: Sum, ``` #### EG ```rust fn main() { let a = [1, 256]; let sum1: i32 = a.iter().sum(); println!("sum1 {:?}", sum1); let b = []; let sum3: u32 = b.iter().sum(); println!("sum3 {:?}", sum3); let b = []; let sum4: f32 = b.iter().sum(); println!("sum4 {:?}", sum4); /* let a = [1, 255]; let sum2: u8 = a.iter().sum(); // 溢出会导致错误panic println!("sum2 {:?}", sum2); */ } /* sum1 257 sum3 0 sum4 -0.0 */ ``` ### `product` #### 说明用于对任何实现 `Product` 的类型（包括 `Option` 和 `Result`）进行乘法运算 > 空迭代器：整数为 `0`，浮点数为` -0.0` > 当返回原始整数类型时，如果计算溢出和调试断言已启用，此方法就会`panic` ```rust fn product

(self) -> P where Self: Sized, P: Product, ``` #### EG ```rust fn main() { let a: i64 = (1..=4).product(); println!("a {:?}", a); let v = vec![2, 3, 4]; let result: i32 = v.into_iter().product(); println!("result {:?}", result); } /* a 24 result 24 */ ``` ### `count` #### 说明统计迭代器中元素数量。比 `collect().len()` 更高效。此方法将重复调用 `next` 直到遇到 `None`，并返回它看到 `Some` 的次数。 > 请注意，即使迭代器中没有任何元素，`next` 也必须至少调用一次 > 在对迭代器中的元素进行计数时，如果元素数量超过 `usize::MAX`，要么会产生错误的结果，要么会出现`panic`。如果启用了调试断言，则保证会出现`panic` ```rust fn count(self) -> usize where Self: Sized, ``` #### EG ```rust fn main() { let v = vec![2, 3, 4]; let result: usize = v.into_iter().count(); println!("result {:?}", result); } /* result 3 */ ``` ### `fold` ##### 说明从一个初始值开始，将每个元素与前一个中间值组合成新值（归约操作） > 注意：`fold()` 以及类似的遍历整个迭代器的方法，可能无法终止无限迭代器 ```rust fn fold(self, init: B, f: F) -> B where Self: Sized, F: FnMut(B, Self::Item) -> B, ``` - `init` 是初始值 - `f` 是折叠函数 `(累积值, 当前元素) -> 新累积值` #### EG ```rust fn main() { let nums = [1, 2, 3]; let sum = nums.iter().fold(3, |acc, x| acc + x); println!("sum {:?}", sum); } /* sum 9 */ ``` ### `reduce` #### 说明类似 `fold`，但没有初始值。将前两个元素作为初始，然后依次组合成新值(归约操作) > 如果迭代器为空，返回 `None` ```rust fn reduce(self, f: F) -> Option where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item, ``` #### EG ```rust fn main() { let nums = [2, 3, 4]; let product = nums.iter().copied().reduce(|a, b| a * b); println!("product {:?}", product); } /* product Some(24) */ ``` ### `all` #### 说明对迭代器中的每个元素应用闭包函数（该函数返回值为`bool`），如果结果有一个为`false`则此函数返回`false` > 空迭代器返回`true` ```rust fn all(&mut self, f: F) -> bool where Self: Sized, F: FnMut(Self::Item) -> bool, ``` #### EG ```rust fn main() { let v = vec![2, 4, 6]; let is_even = v.iter().all(|x| *x % 2 == 0); println!("is_even {:?}", is_even); } /* is_even true */ ``` ### `any` #### 说明对迭代器中的每个元素应用闭包函数（该函数返回值为`bool`），如果闭包函数有一个为`true`则此函数返回`true`, 如果都为`false`则此函数返回`false` > 空迭代器返回`false` ```rust fn any(&mut self, f: F) -> bool where Self: Sized, F: FnMut(Self::Item) -> bool, ``` #### EG ```rust fn main() { let v = vec![1, 3, 4]; let has_even = v.iter().any(|x| *x % 2 == 0); println!("has_even {:?}", has_even); } /* has_even true */ ``` ### `find` #### 说明对迭代器中的每个元素应用闭包函数（该函数返回值为`bool`），如果其中任何一个元素返回 `true`，则`find()`返回` Some(element)`。如果所有元素都返回 `false`，则返回 `None` > 会在第一个符合条件的地方停止 > `iter.find(f) `等同于` iter.filter(f).next()` ```rust fn find

(&mut self, predicate: P) -> Option where Self: Sized, P: FnMut(&Self::Item) -> bool, ``` #### EG ```rust fn main() { let words = vec!["foo", "bar", "baz"]; let found = words.into_iter().find(|s| { println!("item {}", s); s.starts_with("b") }); println!("found {:?}", found); } /* item foo item bar found Some("bar") */ ``` ### `position` #### 说明对迭代器中的每个元素应用闭包函数（该函数返回值为`bool`），如果其中一个元素返回 `true`，则 `position()` 返回 `Some(index)`。如果所有元素都返回 `false`，则返回 `None` > 如果有超过 usize::MAX 的非匹配元素，要么会产生错误结果，要么会出现`panic`。如果启用了调试断言，则肯定会出现`panic` ```rust fn position

(&mut self, predicate: P) -> Option where Self: Sized, P: FnMut(Self::Item) -> bool, ``` #### EG ```rust fn main() { let nums = vec![10, 20, 30]; let index = nums.iter().position(|x| *x == 20); println!("index {:?}", index); } /* index Some(1) */ ``` ### `max` #### 说明返回迭代器中的最大值 - 如果多个元素的最大值相同，则返回最后一个元素 - 如果迭代器为空，则返回 `None` > **请注意**: > > - 由于 `NaN` 不可比 > - `f32/f64` 无法实现 `Ord`。您可以使用 `Iterator::reduce` 来解决这个问题 ```rust fn max(self) -> Option where Self: Sized, Self::Item: Ord, ``` #### EG ```rust fn main() { let values = vec![1.0_f32, 2.0, f32::NAN, 3.0]; let max = values.into_iter().reduce(|a, b| { match (a.is_nan(), b.is_nan()) { (true, true) => f32::NAN, (true, false) => b, (false, true) => a, (false, false) => a.max(b), } }); println!("{:?}", max); // Some(3.0) } /* index Some(1) */ fn safe_max>(iter: I) -> Option { iter.filter(|x| !x.is_nan()).reduce(f64::max) } ``` ### `min` #### 说明返回迭代器中的最小值 - 如果多个元素的最小值相同，则返回第一个元素 - 如果迭代器为空，则返回 `None` > **请注意**: > > - 由于 `NaN` 不可比 > - `f32/f64` 无法实现 `Ord`。您可以使用 `Iterator::reduce` 来解决这个问题 ```rust fn min(self) -> Option where Self: Sized, Self::Item: Ord, ``` #### EG ```rust fn main() { let values = vec![1.0_f32, 2.0, f32::NAN, 3.0]; let min = values.into_iter().reduce(|a, b| { match (a.is_nan(), b.is_nan()) { (true, true) => f32::NAN, (true, false) => b, (false, true) => a, (false, false) => a.min(b), } }); println!("{:?}", min); // Some(3.0) } /* index Some(1.0) */ fn safe_min>(iter: I) -> Option { iter.filter(|x| !x.is_nan()).reduce(f64::min) } ``` ### `last` #### 说明消耗迭代器，返回迭代器中的最后一个元素 ```rust fn last(self) -> Option where Self: Sized, ``` #### EG ```rust fn main() { let values = vec![1.0_f32, 2.0, f32::NAN, 3.0]; let last = values.iter().last(); println!("{:?}", last); // Some(3.0) } ``` ## 特殊工具方法 | 方法名 | 返回类型 | 功能说明 | | -------------- | ----------- | --------------------------- | | `.clone()` | `Clone` | 克隆迭代器（仅当支持时） | | `.copied()` | `Copied` | 将 `&T` 变为 `T`（要求 `T: Copy`） | | `.flatten()` | `Flatten` | 扁平化嵌套的迭代器（如 `Vec>`） | | `.flat_map(f)` | `FlatMap` | `map` + `flatten` 的组合操作 | | `.by_ref()` | `&mut Self` | 创建一个借用迭代器的可重入引用 | ### `flatten` #### 说明将嵌套的迭代器结构“打平”，例如迭代器中的每个元素是另一个 `Iterator` > 常用于 `Vec>`、`Option>`、`Result, E>` 等嵌套结构的迭代 ```rust fn flatten(self) -> Flatten where Self: Sized, Self::Item: IntoIterator, ``` #### EG ```rust fn main() { let nested = vec![vec![1, 2], vec![3, 4]]; let flat: Vec<_> = nested.into_iter().flatten().collect(); println!("{:?}", flat); // [1, 2, 3, 4] } ``` ### `flat_map` #### 说明组合 `.map(f)` 与 `.flatten()`，对每个元素调用 `f` 产生一个可迭代结果，再将其扁平化 > 适合“一个输入多个输出”的场景（比如打散字符、展开选项等） ```rust fn flat_map(self, f: F) -> FlatMap where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U, ``` #### EG ```rust fn main() { let words = vec!["hello", "world"]; let chars: Vec<_> = words.into_iter().flat_map(|s| s.chars()).collect(); println!("{:?}", chars); // ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'] } ``` ### `by_ref` #### 说明创建对迭代器的**可变引用**，使得可以在多个函数中共享同一个迭代器，而不取得所有权。`.by_ref()` 返回 `&mut self` 类型的迭代器引用 > 在 "引用 "适配器上调用消耗方法（直接或间接调用 `next`）将消耗原始迭代器 ```rust fn by_ref(&mut self) -> &mut Self where Self: Sized, ``` #### EG ```rust fn main() { let mut iter = [1, 2, 3, 4].iter(); let first_two: Vec<_> = iter.by_ref().filter(|v| *v % 2 == 0).collect(); let rest: Vec<_> = iter.collect(); println!("{:?}", first_two); // [2, 4] println!("{:?}", rest); // [] } ```