djtu-wiki

Appearance

Iterator ​

迭代器在 Rust 中是一个非常重要和强大的概念。迭代器允许程序员在集合上执行一系列的操作，而不需要明确地循环遍历每个元素。

迭代器的定义

迭代器是一个处理序列的对象。迭代器模式允许你对一个序列进行某种计算，而无需了解或暴露该序列的内部结构。

创建迭代器 大多数的集合类型，例如 Vec, HashMap, 和 HashSet, 都有一个 iter 方法，这个方法返回一个引用该集合的元素的迭代器。

let v = vec![1, 2, 3];
​
let mut iter = v.iter();
​
assert_eq!(Some(&1), iter.next());
assert_eq!(Some(&2), iter.next());
assert_eq!(Some(&3), iter.next());
assert_eq!(None, iter.next());

迭代器方法

迭代器有许多有用的方法，这些方法可以调用来执行不同的操作：

map: 对每个元素执行某个操作。 filter: 基于某个条件筛选元素。 collect: 将迭代器转化为其他的集合类型。 count: 计算元素的数量。 next: 获取迭代器的下一个元素。 等等...

消费迭代器

迭代器是惰性的，意思是它们不会立即执行。为了获取迭代器的结果，你需要消费它。这可以通过多种方式做到，例如使用 collect 方法或简单地用 for 循环遍历它。

let v = vec![1, 2, 3];
​
// 使用for循环消费迭代器
for val in v.iter() {
    println!("{}", val);
}

迭代器的适配性

迭代器是可适配的，意味着你可以链式地调用多个迭代器方法。这使得在集合上执行复杂操作变得非常简洁。

let v = vec![1, 2, 3, 4, 5];
​
let even_squares: Vec<_> = v.iter()
                            .map(|x| x * x)
                            .filter(|&x| x % 2 == 0)
                            .collect();
​
println!("{:?}", even_squares);  // [4, 16]

迭代器与所有权

  1. 基本的迭代与所有权：
    • 使用 iter() 方法获得的是数据的不可变引用，这样你可以安全地多次并发地读取数据，但不能修改它。
    • 如果你想遍历并修改数据，你应该使用 iter_mut()，它返回数据的可变引用。但是，在这种情况下，你不能再次借用原始数据，直到迭代器的生命周期结束。
  2. 所有权与迭代器的消费：
    • 有些迭代器方法是“消费性”的，这意味着一旦调用，迭代器就不能再被使用。例如，collect 方法就会消耗迭代器，并将元素收集到一个新的容器中。
    • into_iter 方法是从一个集合创建迭代器的方法，这个方法会获取集合的所有权，因此返回的迭代器产生的项目将是集合的值本身，而不是引用。
  3. 方法链与所有权：
    • Rust 的迭代器允许方法链，如 iter().map(...).filter(...).collect()。这样的链式调用在处理所有权和生命周期时非常明确，确保在整个链中的每一步都是安全的。
  4. 迭代器的适配器与所有权：
    • 迭代器有许多“适配器”方法，如 map 和 filter。这些方法通常接受一个函数或闭包，并可能改变迭代器的行为或其产生的值。在使用这些适配器时，闭包中捕获的变量的所有权和生命周期都是有效的，Rust 的编译器会确保这一点。
  5. 迭代器中的值的所有权：
    • 当迭代器产生的值是对象的所有权时（例如使用 into_iter），一旦这些值被迭代出来，原始集合就不能再使用了。这确保了在迭代过程中不会违反 Rust 的所有权规则。

迭代器的返回

迭代器是不能返回值的，迭代器在Rust中是惰性的，并且是消耗性的。当你从迭代器中请求一个元素（例如，通过调用next()方法）时，迭代器会前进到下一个元素，你不能再次“回到”之前的元素。因此，一旦迭代器被完全消耗（例如，通过一个循环），你不能再从中获取元素。

但是，有几种方式可以再次使用或"重置"迭代器：

  1. 创建一个新的迭代器实例：如果迭代器是由某种集合（如Vec或String）创建的，你可以简单地再次调用相应的iter方法来获得一个新的迭代器。
  2. 克隆迭代器：如果迭代器实现了Clone trait，并且它的元素也是克隆的，你可以在开始迭代之前克隆它。这样，你可以保留原始的迭代器并在需要时使用克隆的迭代器。
  3. 使用peekable：peekable方法返回一个特殊类型的迭代器，它允许你查看下一个元素而不消耗它。这对于某些用例很有用，但并不完全等同于"重置"迭代器。
  4. 使用collect将迭代器转化为集合：如果你知道你可能需要多次遍历数据，你可以考虑将其收集到Vec或其他集合中。然后，你可以多次迭代这个集合，每次都获得一个新的迭代器。

要注意的是，不是所有的迭代器都可以轻易地重新获得或克隆。例如，从文件或网络流中读取的迭代器可能不能重置，除非你重新打开文件或重新连接。因此，在设计使用迭代器的代码时，考虑迭代器的消耗性质是很重要的。

迭代器的类型转换操作

迭代器提供了一系列的适配器方法，许多这些方法都可以看作是类型转换操作。它们接收一个迭代器并返回一个新的，产生不同类型的值或以不同的方式操作值的迭代器。以下是一些常用的迭代器适配器方法和它们如何进行类型转换：

  1. map:

    • map 方法接受一个函数，该函数处理迭代器产生的每个元素，并将其转换为一个新的类型。
    let numbers = vec![1, 2, 3];
let squared: Vec<_> = numbers.iter().map(|&x| x * x).collect();

  2. filter:

    • filter 方法返回一个新的迭代器，只包含使给定谓词为真的元素。
    let numbers = vec![1, 2, 3, 4, 5];
let even: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect();

  3. flat_map:

    • flat_map 用于将每个元素转换为另一个迭代器，然后将这些迭代器的内容平坦化为一个单一的连续迭代器。
    let words = vec!["hello", "world"];
let characters: Vec<_> = words.iter().flat_map(|&word| word.chars()).collect();

  4. enumerate:

    • enumerate 为每个元素提供一个计数器，返回一个元组，其中第一个元素是计数器，第二个元素是原始迭代器的值。
    let colors = vec!["red", "green", "blue"];
for (index, color) in colors.iter().enumerate() {
    println!("Color {}: {}", index, color);
}

  5. zip:

    • zip 方法将两个迭代器合并为一个，产生一个元组，其中第一个元素来自第一个迭代器，第二个元素来自第二个迭代器。
    let names = vec!["Alice", "Bob"];
let ages = vec![25, 30];
let combined: Vec<_> = names.iter().zip(ages.iter()).collect();

  6. collect:

    • 虽然 collect 不直接改变每个元素的类型，但它将迭代器转换为集合类型，如 Vec, HashSet, HashMap 等。

迭代器适配器

迭代器适配器是Rust中的一种强大工具，允许你修改或转换迭代器的行为。这些适配器提供了一种方法，用于操作或处理一个迭代器的元素，然后返回一个新的迭代器。这样，你可以链式地应用多个适配器，形成一个复杂的操作序列。

以下是一些常用的迭代器适配器：

  1. map:

    • 转换每个元素。
    let numbers = vec![1, 2, 3];
let doubled: Vec<_> = numbers.iter().map(|&x| x * 2).collect();

  2. filter:

    • 仅保留满足某个条件的元素。
    let numbers = vec![1, 2, 3, 4, 5];
let even: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect();

  3. flat_map:

    • 转换每个元素为一个迭代器，然后将这些迭代器的内容合并到一个连续的迭代器中。
    let words = vec!["hello", "world"];
let letters: Vec<_> = words.iter().flat_map(|&word| word.chars()).collect();

  4. count:

    • 计算元素的数量。
    let numbers = vec![1, 2, 3];
let total = numbers.iter().count();

  5. fold:

    • 累积所有元素。
    let numbers = vec![1, 2, 3];
let sum = numbers.iter().fold(0, |acc, &x| acc + x);

  6. zip:

    • 合并两个迭代器。
    let names = vec!["Alice", "Bob"];
let ages = vec![25, 30];
let combined: Vec<_> = names.iter().zip(ages.iter()).collect();

  7. skip 和 take:

    • 跳过前N个元素或仅取前N个元素。
    let numbers = vec![1, 2, 3, 4, 5];
let last_three: Vec<_> = numbers.iter().skip(2).collect();

  8. peekable:

    • 允许预览下一个元素而不消费它。

  9. chain:

    • 连接两个迭代器。

\