next 方法
核心概念
next() 是 Iterator trait 中唯一必须实现的方法,签名为 fn next(&mut self) -> Option<Self::Item>。每次调用 next() 会尝试产出迭代器中的下一个元素:返回 Some(值) 表示成功产出一个元素,返回 None 表示迭代结束。next() 接受 &mut self,意味着每次调用都会修改迭代器的内部状态(推进位置)。所有迭代器的高级方法(map、filter、collect、for 循环等)在底层都是通过反复调用 next() 来工作的。
fn main() {
let fruits = vec!["苹果", "香蕉", "橘子"];
let mut iter = fruits.iter();
// 手动调用 next()
let first = iter.next(); // Some(&"苹果")
let second = iter.next(); // Some(&"香蕉")
let third = iter.next(); // Some(&"橘子")
let end = iter.next(); // None
println!("第一个: {:?}", first);
println!("第二个: {:?}", second);
println!("第三个: {:?}", third);
println!("结束: {:?}", end);
// 继续调用 next() 仍然返回 None
println!("再次: {:?}", iter.next()); // None
}next() 与 for 循环的关系
fn main() {
let data = vec![10, 20, 30];
// for 循环的本质:
// 1. 调用 into_iter() 获取迭代器
// 2. 反复调用 next()
// 3. 遇到 None 时退出
// for 循环写法
for item in data.iter() {
print!("{} ", item);
}
println!();
// 等价的手动 next() 写法
let mut iter = data.iter();
loop {
match iter.next() {
Some(item) => print!("{} ", item),
None => break,
}
}
println!();
// while let 写法(更简洁的手动方式)
let mut iter = data.iter();
while let Some(item) = iter.next() {
print!("{} ", item);
}
println!();
}next() 的 &mut self
fn main() {
let nums = vec![1, 2, 3, 4, 5];
let mut iter = nums.iter();
// next() 修改迭代器状态,需要 &mut self
// 所以 iter 必须是 mut
// 消费前两个
println!("消费: {:?}", iter.next()); // Some(&1)
println!("消费: {:?}", iter.next()); // Some(&2)
// 剩下的元素可以继续用其他方法处理
let remaining: Vec<&&i32> = iter.collect();
println!("剩余: {:?}", remaining); // [&3, &4, &5]
// 部分消费后用 for 循环处理剩余
let data = vec!["a", "b", "c", "d", "e"];
let mut iter = data.iter();
// 跳过前两个
iter.next();
iter.next();
// for 循环处理剩余
print!("剩余: ");
for item in iter {
print!("{} ", item);
}
println!(); // c d e
}在自定义迭代器中实现 next()
// 范围步进迭代器
struct StepRange {
current: i64,
end: i64,
step: i64,
}
impl StepRange {
fn new(start: i64, end: i64, step: i64) -> Self {
StepRange {
current: start,
end,
step,
}
}
}
impl Iterator for StepRange {
type Item = i64;
fn next(&mut self) -> Option<i64> {
if (self.step > 0 && self.current >= self.end)
|| (self.step < 0 && self.current <= self.end)
{
None // 到达边界,迭代结束
} else {
let value = self.current;
self.current += self.step; // 推进状态
Some(value)
}
}
}
// 字符串分段迭代器
struct Chunks<'a> {
data: &'a str,
size: usize,
pos: usize,
}
impl<'a> Chunks<'a> {
fn new(data: &'a str, size: usize) -> Self {
Chunks { data, size, pos: 0 }
}
}
impl<'a> Iterator for Chunks<'a> {
type Item = &'a str;
fn next(&mut self) -> Option<&'a str> {
if self.pos >= self.data.len() {
None
} else {
let end = (self.pos + self.size).min(self.data.len());
let chunk = &self.data[self.pos..end];
self.pos = end;
Some(chunk)
}
}
}
fn main() {
// 步进范围
println!("步进2 (0..10):");
let stepped: Vec<i64> = StepRange::new(0, 10, 2).collect();
println!(" {:?}", stepped);
println!("步进3 (1..20):");
let stepped: Vec<i64> = StepRange::new(1, 20, 3).collect();
println!(" {:?}", stepped);
println!("倒数 (10..0, step=-2):");
let countdown: Vec<i64> = StepRange::new(10, 0, -2).collect();
println!(" {:?}", countdown);
// 字符串分段
println!("\n字符串分段:");
let text = "HelloRustWorld";
for chunk in Chunks::new(text, 4) {
println!(" '{}'", chunk);
}
}next() 与 peek()
fn main() {
let data = vec![1, 2, 3, 4, 5];
// peekable() 可以查看下一个元素但不消费它
let mut iter = data.iter().peekable();
// peek() 返回 Option<&&i32>,不推进迭代器
println!("偷看: {:?}", iter.peek()); // Some(&&1)
println!("偷看: {:?}", iter.peek()); // 仍然是 Some(&&1)
// next() 消费元素,推进迭代器
println!("消费: {:?}", iter.next()); // Some(&1)
println!("偷看: {:?}", iter.peek()); // Some(&&2)
// 利用 peek 实现条件消费
let nums = vec![1, 3, 5, 2, 4, 6, 8, 7];
let mut iter = nums.iter().peekable();
// 收集连续的奇数
let mut odds = Vec::new();
while let Some(&&n) = iter.peek() {
if n % 2 == 1 {
odds.push(*iter.next().unwrap());
} else {
break;
}
}
// 收集剩余元素
let rest: Vec<&i32> = iter.collect();
println!("连续奇数: {:?}", odds);
println!("剩余: {:?}", rest);
}基本示例
用 next() 实现一个 CSV 行解析迭代器:
// CSV 字段迭代器
struct CsvFields<'a> {
line: &'a str,
pos: usize,
}
impl<'a> CsvFields<'a> {
fn new(line: &'a str) -> Self {
CsvFields { line, pos: 0 }
}
}
impl<'a> Iterator for CsvFields<'a> {
type Item = &'a str;
fn next(&mut self) -> Option<&'a str> {
// 已经到末尾
if self.pos > self.line.len() {
return None;
}
if self.pos == self.line.len() {
// 处理末尾空字段的情况
self.pos = self.line.len() + 1;
return Some("");
}
// 查找下一个逗号
let remaining = &self.line[self.pos..];
match remaining.find(',') {
Some(comma_pos) => {
let field = &self.line[self.pos..self.pos + comma_pos];
self.pos += comma_pos + 1; // 跳过逗号
Some(field.trim())
}
None => {
// 最后一个字段
let field = &self.line[self.pos..];
self.pos = self.line.len() + 1; // 标记结束
Some(field.trim())
}
}
}
}
fn main() {
// 解析 CSV 行
let lines = vec![
"张三, 25, 北京, 工程师",
"李四, 30, 上海, 设计师",
"王五, 28, 广州, 产品经理",
];
println!("=== CSV 解析 ===");
for line in &lines {
let fields: Vec<&str> = CsvFields::new(line).collect();
println!("字段数: {}, 内容: {:?}", fields.len(), fields);
}
// 手动用 next() 逐字段处理
println!("\n=== 逐字段处理 ===");
let record = "Rust, 2015, Mozilla, 系统编程";
let mut fields = CsvFields::new(record);
if let Some(name) = fields.next() {
println!("名称: {}", name);
}
if let Some(year) = fields.next() {
println!("年份: {}", year);
}
// 剩余字段
let rest: Vec<&str> = fields.collect();
println!("其他: {:?}", rest);
// 使用迭代器方法
println!("\n=== 迭代器方法 ===");
let data = "10, 20, 30, 40, 50";
let sum: i32 = CsvFields::new(data)
.filter_map(|f| f.parse::<i32>().ok())
.sum();
println!("数字总和: {}", sum);
let count = CsvFields::new(data).count();
println!("字段数量: {}", count);
}常见问题
问题一:next() 返回 None 后还能继续调用吗?
可以调用,但标准约定是返回 None 后应该持续返回 None。这叫做"融合"(fused)行为。如果需要保证这一点,可以用 .fuse() 适配器包装。
问题二:next() 里可以做耗时操作吗?
可以。next() 就是普通的方法调用,可以做任何计算,包括 IO 操作。但要注意,迭代器的使用者可能不知道 next() 的开销,所以文档中应说明。
问题三:为什么 next() 需要 &mut self?
因为每次调用 next() 都会推进迭代器的内部位置。这是一个修改操作,需要可变引用。
问题四:一次 next() 调用可以产出多个值吗?
不可以。next() 每次只返回一个 Option<Item>。如果需要批量产出,可以让 Item 是一个集合类型(如 Vec),或使用 flat_map。
适用场景
- 自定义数据源:文件读取、网络数据、传感器数据
- 数学序列:斐波那契、素数、阶乘
- 解析器:逐 token/逐字段解析
- 有限状态机:每次 next() 推进一步状态
注意事项
next()是 Iterator trait 唯一必须实现的方法- 返回
Some(值)表示有下一个元素,None表示结束 next()接受&mut self,会修改迭代器状态- 返回
None后应持续返回None for循环、collect、sum等底层都是调用next()peekable()可以查看下一个元素但不消费它
总结
next() 是 Iterator trait 的核心方法,每次调用产出一个 Option<Self::Item>:Some(值) 表示有元素,None 表示结束。实现自定义迭代器只需要定义这一个方法,就能自动获得几十个迭代器方法。next() 通过 &mut self 修改内部状态来推进迭代位置。for 循环和所有迭代器消费器在底层都是反复调用 next()。用 peekable() 可以在不消费元素的情况下查看下一个值。返回 None 后应持续返回 None(融合语义)。