iter vs into_iter vs iter_mut ​

核心概念 ​

Rust 集合类型提供三种获取迭代器的方式:iter() 产出不可变引用 &T,into_iter() 消耗集合并产出拥有所有权的 T,iter_mut() 产出可变引用 &mut T。选择哪种取决于你的需求:只读访问用 iter(),需要修改元素用 iter_mut(),需要取走元素所有权用 into_iter()。

rust
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
rust
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);
}

不同集合类型的行为 ​

rust
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!();
}

链式操作中的选择 ​

rust
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);
}

基本示例 ​

展示三种迭代方式在实际数据处理中的选择:

rust
#[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()。