异常教程

Rust 迭代器（建议收藏）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

迭代器是 Rust 语言中用于遍历数据结构的核心工具。无论是处理列表、集合还是其他可迭代对象，迭代器都能以简洁、安全且高效的方式完成任务。对于编程初学者而言，理解迭代器的工作原理可以显著提升代码的可读性和性能；而对中级开发者来说，掌握迭代器的高级技巧则能进一步优化代码结构，实现复杂的数据处理逻辑。本文将通过循序渐进的方式，结合实际案例，深入讲解 Rust 迭代器的原理、方法及应用场景。

什么是迭代器？

在 Rust 中，迭代器（Iterator） 是一种通过 Iterator trait 定义的抽象机制，用于逐个访问集合中的元素。想象一个传送带，元素像货物一样依次通过，而迭代器就是控制传送带运作的“操作员”。它的核心功能是通过 next() 方法逐个返回元素，直到没有元素可返回为止。

迭代器的基本工作流程

迭代器的工作流程可以分为三个步骤：

  1. 创建迭代器：从集合（如 Vec、HashMap、String 等）生成一个迭代器实例。
  2. 遍历元素：通过 next() 方法逐个获取元素，直到返回 None。
  3. 处理元素：在遍历过程中对元素进行过滤、转换或其他操作。
let numbers = vec![1, 2, 3];
let mut iter = numbers.iter();

while let Some(num) = iter.next() {
    println!("当前元素：{}", num);
}

迭代器的创建与基础方法

从集合创建迭代器

Rust 提供了多种方法从集合中创建迭代器，常见的包括：

  • into_iter()：消耗集合的所有权，直接遍历原始数据。
  • iter()：返回不可变引用的迭代器。
  • iter_mut()：返回可变引用的迭代器。

示例：遍历向量元素

let vec = vec![10, 20, 30];

// 不可变遍历
for num in vec.iter() {
    println!("元素值：{}", num); // 输出 10、20、30
}

// 可变遍历
let mut mutable_vec = vec![40, 50];
for num in mutable_vec.iter_mut() {
    *num += 10; // 修改元素值
}
assert_eq!(mutable_vec, vec![50, 60]);

迭代器的遍历方式

除了 while let 循环，Rust 还支持更简洁的 for...in 语法直接遍历迭代器：

let array = [1, 2, 3];
for &element in array.iter() {
    println!("元素值：{}", element); // 输出 1、2、3
}

常用迭代器适配器

迭代器的真正威力在于其适配器（Adapter）方法，这些方法可以对迭代过程进行“装饰”，实现过滤、映射、折叠等操作。适配器通过链式调用组合，形成高效的流水线。

1. map(): 转换元素

map() 方法对每个元素执行闭包，返回新的迭代器。它类似于“传送带上的加工环节”，将每个元素转换为另一种形式。

示例：将数值平方

let numbers = vec![1, 2, 3];
let squares: Vec<_> = numbers.iter().map(|x| x * x).collect();
assert_eq!(squares, vec![1, 4, 9]);

2. filter(): 筛选元素

filter() 根据条件保留符合条件的元素，相当于在传送带上设置一个筛选器，只让符合条件的“货物”通过。

示例：筛选偶数

let numbers = vec![1, 2, 3, 4, 5];
let evens: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
assert_eq!(evens, vec![2, 4]);

3. fold(): 累积计算

fold() 通过初始值和闭包，对元素进行累积操作（如求和、计数），类似“流水线上的总和计算器”。

示例：计算列表总和

let numbers = vec![1, 2, 3];
let sum = numbers.iter().fold(0, |acc, &x| acc + x);
assert_eq!(sum, 6);

其他常用适配器

  • take(n): 限制迭代器只取前 n 个元素。
  • skip(n): 跳过前 n 个元素。
  • chain(): 将两个迭代器合并为一个。
  • rev(): 反转迭代顺序（仅适用于 Vec、String 等可逆容器）。

链式调用与惰性求值

迭代器的链式调用（Chaining）允许将多个适配器组合，形成简洁高效的处理流水线。例如：

let numbers = vec![3, 1, 4, 1, 5, 9];
let result: Vec<_> = numbers
    .iter()
    .filter(|&&x| x > 3)
    .map(|&x| x * 2)
    .collect();
// result 将是 [8, 10, 18]

惰性求值（Lazy Evaluation）

迭代器的适配器方法不会立即执行，而是等到需要结果时才开始计算。这种“按需计算”的特性称为惰性求值，类似于“按订单生产货物”，而非一次性处理所有数据。

示例：避免提前计算

let numbers = vec![1, 2, 3];
let filtered = numbers.iter().filter(|&&x| x > 2);
// 此时未执行过滤，直到遍历或调用 collect()
let result: Vec<_> = filtered.collect();
assert_eq!(result, vec![&3]);

高级技巧：自定义迭代器

实现自定义迭代器

通过实现 Iterator trait，可以创建自定义迭代器。例如，实现一个生成斐波那契数列的迭代器：

struct Fibonacci {
    curr: u32,
    next: u32,
}

impl Iterator for Fibonacci {
    type Item = u32;
    fn next(&mut self) -> Option<Self::Item> {
        let new_next = self.curr + self.next;
        Some(self.curr) // 返回当前值
    }
}

// 使用自定义迭代器
let fib = Fibonacci { curr: 1, next: 1 };
for num in fib.take(5) {
    println!("{}", num); // 输出 1、1、2、3、5
}

使用 IntoIterator trait

通过实现 IntoIterator trait，可以为自定义类型定义迭代行为。例如，为元组实现迭代：

struct TupleIter<T>(T);

impl<T> IntoIterator for TupleIter<(T, T)> {
    type Item = T;
    type IntoIter = std::array::IntoIter<T, 2>;

    fn into_iter(self) -> Self::IntoIter {
        [self.0 .0, self.0 .1].into_iter()
    }
}

let tuple = TupleIter((1, 2));
for num in tuple {
    println!("{}", num); // 输出 1、2
}

性能优化与注意事项

避免不必要的克隆

在迭代过程中，尽量使用引用而非克隆数据。例如：

let strings = vec![String::from("Rust"), String::from("Iterator")];
for s in &strings { // 使用引用，避免克隆
    println!("{}", s);
}

使用 by_ref() 修改可变状态

当需要在遍历中修改迭代器状态时，使用 by_ref() 方法获取可变引用：

let mut numbers = vec![1, 2, 3];
let mut iter = numbers.iter();

// 错误示例：直接修改迭代器
// iter.next().unwrap().clone() += 1; // 编译报错

// 正确方式：通过 by_ref()
if let Some(num) = iter.by_ref().next() {
    *num = 10; // 假设 numbers 是可变的
}

处理可变与不可变引用

迭代器在遍历时会借用集合，因此无法同时拥有可变和不可变引用。例如：

let mut vec = vec![1, 2, 3];
let iter = vec.iter(); // 不可变引用
// vec.push(4); // 编译报错：存在不可变引用时无法修改

实际案例：文件行迭代器

假设需要逐行读取文件并统计行数，可以结合 BufReader 和迭代器：

use std::fs::File;
use std::io::{self, BufRead};

fn count_lines(file_path: &str) -> io::Result<usize> {
    let file = File::open(file_path)?;
    let reader = io::BufReader::new(file);
    Ok(reader.lines().filter_map(Result::ok).count())
}

// 使用示例
let line_count = count_lines("example.txt")?;
println!("文件共有 {} 行", line_count);

结论

Rust 迭代器通过抽象化的数据遍历机制，为开发者提供了高效、安全且灵活的编程体验。无论是基础的遍历操作，还是通过适配器构建复杂的数据流水线，迭代器都能显著提升代码的简洁性和性能。掌握迭代器的惰性求值特性、链式调用技巧以及自定义迭代器的实现方法，将进一步扩展 Rust 程序的表达能力。对于初学者而言，从简单案例入手，逐步探索适配器的组合逻辑；对中级开发者，可以尝试通过迭代器优化算法或实现领域特定的数据处理流程。Rust 迭代器不仅是语言设计的精华之一，更是构建可靠、高性能 Rust 程序的重要工具。

最新发布

查看更多文章