iter vs into_iter vs iter_mut
核心概念
Rust 集合类型提供三种获取迭代器的方式:iter() 产出不可变引用 &T,into_iter() 消耗集合并产出拥有所有权的 T,iter_mut() 产出可变引用 &mut T。选择哪种取决于你的需求:只读访问用 iter(),需要修改元素用 iter_mut(),需要取走元素所有权用 into_iter()。
fn main() {
let mut names = vec![
String::from("Alice"),
String::from("Bob"),
String::from("Charlie"),
];
// iter():不可变引用,集合不被修改或消耗
println!("iter() - 只读:");
for name in names.iter() {
// name 的类型是 &String
println!(" {}", name);
}
println!("集合仍在: {:?}", names);
// iter_mut():可变引用,可以修改元素
println!("\niter_mut() - 修改:");
for name in names.iter_mut() {
// name 的类型是 &mut String
name.push_str("!");
}
println!("修改后: {:?}", names);
// into_iter():消耗集合,获取所有权
println!("\ninto_iter() - 消耗:");
for name in names.into_iter() {
// name 的类型是 String(拥有所有权)
println!(" 拥有: {}", name);
}
// names 已被消耗
// println!("{:?}", names); // 编译错误
}三种方式的对比
| 方法 | 产出类型 | 集合是否消耗 | 能否修改元素 | for 循环等价写法 |
|---|---|---|---|---|
iter() | &T | 否 | 不能 | for x in &collection |
iter_mut() | &mut T | 否 | 可以 | for x in &mut collection |
into_iter() | T | 是 | 拥有所有权 | for x in collection |
fn main() {
let mut data = vec![1, 2, 3, 4, 5];
// iter() 等价于 for x in &data
let sum: i32 = data.iter().sum();
println!("sum(iter) = {}", sum);
// iter_mut() 等价于 for x in &mut data
data.iter_mut().for_each(|x| *x *= 2);
println!("doubled = {:?}", data);
// into_iter() 等价于 for x in data
let collected: Vec<String> = data.into_iter()
.map(|x| format!("#{}", x))
.collect();
println!("collected = {:?}", collected);
}不同集合类型的行为
use std::collections::HashMap;
fn main() {
// === Vec ===
let v = vec![10, 20, 30];
let refs: Vec<&i32> = v.iter().collect(); // &i32
let owned: Vec<i32> = v.into_iter().collect(); // i32
println!("Vec refs: {:?}", refs);
println!("Vec owned: {:?}", owned);
// === HashMap ===
let mut map = HashMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);
// iter() -> (&K, &V)
for (key, value) in map.iter() {
println!(" {} = {}", key, value);
}
// iter_mut() -> (&K, &mut V)(键不可变,值可变)
for (_, value) in map.iter_mut() {
*value *= 10;
}
println!("map 修改后: {:?}", map);
// into_iter() -> (K, V)
let pairs: Vec<(&str, i32)> = map.into_iter().collect();
println!("pairs: {:?}", pairs);
// === 数组 ===
let arr = [1, 2, 3];
// 数组的 iter() 产出 &i32
let sum: i32 = arr.iter().sum();
println!("数组 sum: {}", sum);
// 数组的 into_iter()(Rust 2021+)产出 i32
let doubled: Vec<i32> = arr.into_iter().map(|x| x * 2).collect();
println!("数组 doubled: {:?}", doubled);
// === String ===
let s = String::from("hello");
// chars() 类似于 iter(),产出 char
for c in s.chars() {
print!("{} ", c);
}
println!();
}链式操作中的选择
fn main() {
let words = vec![
String::from("hello"),
String::from("world"),
String::from("rust"),
String::from("programming"),
];
// iter():不消耗,后续还能用 words
let lengths: Vec<usize> = words.iter().map(|w| w.len()).collect();
println!("长度: {:?}", lengths);
println!("words 仍在: {:?}", words);
// iter() + cloned():复制元素,不消耗集合
let upper: Vec<String> = words.iter()
.cloned() // 复制 String
.map(|w| w.to_uppercase())
.collect();
println!("大写: {:?}", upper);
println!("words 仍在: {:?}", words);
// into_iter():消耗集合,省去复制的开销
let upper_owned: Vec<String> = words.into_iter()
.map(|w| w.to_uppercase()) // w 拥有 String 的所有权
.collect();
println!("大写(owned): {:?}", upper_owned);
// words 已消耗
// 修改场景
let mut scores = vec![85.0, 92.0, 78.0, 95.0, 88.0];
// iter_mut():就地修改
let curve = 5.0;
scores.iter_mut().for_each(|s| *s += curve);
println!("加分后: {:?}", scores);
}基本示例
展示三种迭代方式在实际数据处理中的选择:
#[derive(Debug, Clone)]
struct Employee {
name: String,
department: String,
salary: f64,
}
impl Employee {
fn new(name: &str, dept: &str, salary: f64) -> Self {
Employee {
name: name.to_string(),
department: dept.to_string(),
salary,
}
}
}
fn main() {
let mut employees = vec![
Employee::new("张三", "工程", 15000.0),
Employee::new("李四", "设计", 12000.0),
Employee::new("王五", "工程", 18000.0),
Employee::new("赵六", "市场", 13000.0),
Employee::new("钱七", "工程", 16000.0),
];
// === iter():查询和统计(不修改数据)===
println!("=== 统计信息 ===");
// 平均薪资
let avg_salary: f64 = employees.iter()
.map(|e| e.salary)
.sum::<f64>() / employees.len() as f64;
println!("平均薪资: {:.0}", avg_salary);
// 按部门分组统计
let eng_count = employees.iter()
.filter(|e| e.department == "工程")
.count();
println!("工程部人数: {}", eng_count);
// 查找最高薪资
let top = employees.iter()
.max_by(|a, b| a.salary.partial_cmp(&b.salary).unwrap());
if let Some(emp) = top {
println!("最高薪资: {} ({:.0})", emp.name, emp.salary);
}
// 所有员工名单
let names: Vec<&str> = employees.iter()
.map(|e| e.name.as_str())
.collect();
println!("员工: {:?}", names);
// === iter_mut():批量修改 ===
println!("\n=== 调薪 ===");
// 工程部加薪 10%
employees.iter_mut()
.filter(|e| e.department == "工程")
.for_each(|e| {
let raise = e.salary * 0.10;
println!(" {} 加薪 {:.0}", e.name, raise);
e.salary += raise;
});
// 修改后的数据
println!("\n调薪后:");
for emp in &employees {
println!(" {} ({}) - {:.0}", emp.name, emp.department, emp.salary);
}
// === into_iter():转换数据格式 ===
println!("\n=== 转换为报告 ===");
// 消耗集合生成报告
let reports: Vec<String> = employees.into_iter()
.map(|e| format!("{} | {} | ¥{:.0}", e.name, e.department, e.salary))
.collect();
for report in &reports {
println!(" {}", report);
}
// employees 已被消耗
}常见问题
问题一:什么时候用 iter(),什么时候用 into_iter()?
如果之后还需要使用集合,用 iter()。如果集合用完不再需要,或需要获取元素的所有权,用 into_iter()。into_iter() 可以省去 clone() 的开销。
问题二:for x in &vec 和 for x in vec.iter() 有区别吗?
没有区别。for x in &vec 会调用 (&vec).into_iter(),而 Vec 的 &Vec<T> 的 IntoIterator 实现和 iter() 返回相同的迭代器。
问题三:iter().cloned() 和 into_iter() 有什么区别?
iter().cloned() 借用集合并克隆每个元素,集合不被消耗但有克隆开销。into_iter() 消耗集合并直接移走元素所有权,没有克隆开销但集合不能再用。
问题四:Copy 类型用哪种迭代方式?
Copy 类型(如 i32、f64)三种方式都行。iter() 产出 &i32,但解引用是免费的。into_iter() 产出 i32,集合被消耗。通常用 iter() 就够了。
适用场景
iter():查询、统计、只读遍历iter_mut():批量修改、就地更新into_iter():数据转换、消耗后重建、传入需要所有权的函数
注意事项
iter()产出&T,集合不消耗iter_mut()产出&mut T,可修改元素但不改变集合结构into_iter()产出T,集合被消耗for x in &collection等价于for x in collection.iter()for x in &mut collection等价于for x in collection.iter_mut()for x in collection等价于for x in collection.into_iter()- 数组在 Rust 2021 edition 中
into_iter()产出元素而非引用
总结
iter()、into_iter()、iter_mut() 是获取迭代器的三种方式。iter() 产出不可变引用 &T,集合不被消耗,适合只读场景。iter_mut() 产出可变引用 &mut T,可以修改元素。into_iter() 消耗集合并产出拥有所有权的 T,适合数据转换和不再需要原集合的场景。在 for 循环中,&collection 等价于 collection.iter(),&mut collection 等价于 collection.iter_mut(),直接写 collection 等价于 collection.into_iter()。选择的核心原则是:不需要修改用 iter(),需要修改用 iter_mut(),不再需要原集合用 into_iter()。