map 适配器 ​

核心概念 ​

map() 是迭代器最常用的适配器方法,它接受一个闭包,对迭代器中的每个元素应用这个闭包,产出一个新的迭代器。map() 不会改变元素的数量,只改变元素的值或类型。map() 是惰性的——调用 map() 不会立即执行任何计算,只有在消费器(如 collect、for_each、sum)驱动时才会逐个处理元素。

rust
fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // map:将每个数字乘以 2
    let doubled: Vec<i32> = numbers.iter()
        .map(|&x| x * 2)
        .collect();
    println!("翻倍: {:?}", doubled);

    // map:改变类型(i32 → String)
    let strings: Vec<String> = numbers.iter()
        .map(|&x| format!("#{}", x))
        .collect();
    println!("字符串: {:?}", strings);

    // map:提取字段
    let words = vec!["hello", "world", "rust"];
    let lengths: Vec<usize> = words.iter()
        .map(|w| w.len())
        .collect();
    println!("长度: {:?}", lengths);
}

map 的惰性特性 ​

rust
fn main() {
    let data = vec![1, 2, 3];

    // 创建 map 迭代器不会执行闭包
    let iter = data.iter().map(|&x| {
        println!("  处理: {}", x);  // 不会打印
        x * 10
    });
    println!("map 已创建,但未执行");

    // collect 触发实际执行
    println!("开始 collect:");
    let result: Vec<i32> = iter.collect();
    println!("结果: {:?}", result);

    // 元素是按需处理的(拉取模式)
    println!("\n逐个拉取:");
    let mut iter = data.iter().map(|&x| {
        println!("  map: {}", x);
        x * 100
    });
    println!("调用 next():");
    println!("  结果: {:?}", iter.next());  // 只处理第一个
    println!("再次 next():");
    println!("  结果: {:?}", iter.next());  // 只处理第二个
}

map 的类型转换 ​

rust
fn main() {
    // 整数 → 浮点数
    let ints = vec![1, 2, 3, 4, 5];
    let floats: Vec<f64> = ints.iter().map(|&x| x as f64).collect();
    println!("浮点: {:?}", floats);

    // &str → String
    let slices = vec!["hello", "world"];
    let owned: Vec<String> = slices.iter().map(|&s| s.to_string()).collect();
    println!("String: {:?}", owned);

    // String → (String, usize)(附加信息)
    let names = vec![String::from("Alice"), String::from("Bob"), String::from("Charlie")];
    let with_lengths: Vec<(String, usize)> = names.into_iter()
        .map(|name| {
            let len = name.len();
            (name, len)
        })
        .collect();
    println!("带长度: {:?}", with_lengths);

    // 元组解构
    let pairs = vec![(1, "a"), (2, "b"), (3, "c")];
    let first_elements: Vec<i32> = pairs.iter().map(|&(n, _)| n).collect();
    let second_elements: Vec<&&str> = pairs.iter().map(|(_, s)| s).collect();
    println!("第一列: {:?}", first_elements);
    println!("第二列: {:?}", second_elements);
}

map 与其他适配器链式调用 ​

rust
fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // map + filter
    let result: Vec<i32> = data.iter()
        .map(|&x| x * x)          // 先平方
        .filter(|&x| x > 20)      // 再过滤
        .collect();
    println!("平方后>20: {:?}", result);

    // filter + map(先过滤再转换)
    let result: Vec<String> = data.iter()
        .filter(|&&x| x % 2 == 0)  // 先过滤偶数
        .map(|&x| format!("偶数:{}", x))  // 再格式化
        .collect();
    println!("{:?}", result);

    // map + map(多层转换)
    let result: Vec<String> = data.iter()
        .map(|&x| x * 3)          // 乘以3
        .map(|x| x + 1)           // 加1
        .map(|x| x.to_string())   // 转字符串
        .collect();
    println!("多层map: {:?}", result);

    // map + take + collect
    let first_five_squares: Vec<i32> = (1..)
        .map(|x| x * x)
        .take(5)
        .collect();
    println!("前5个平方: {:?}", first_five_squares);

    // map + enumerate
    let indexed: Vec<(usize, String)> = vec!["a", "b", "c"].iter()
        .map(|&s| s.to_uppercase())
        .enumerate()
        .collect();
    println!("带索引: {:?}", indexed);
}

map 与 for_each 的对比 ​

rust
fn main() {
    let nums = vec![1, 2, 3, 4, 5];

    // map + collect:变换并收集结果
    let result: Vec<i32> = nums.iter().map(|&x| x * 2).collect();
    println!("map结果: {:?}", result);

    // for_each:只执行副作用,不返回新集合
    nums.iter()
        .map(|&x| x * 2)
        .for_each(|x| print!("{} ", x));
    println!();

    // 如果只需要副作用(如打印),for_each 比 map+collect 好
    // map 用于转换数据,for_each 用于副作用
    
    // 不要用 map 做副作用然后丢弃结果
    // 这是不好的写法(编译器会警告):
    // nums.iter().map(|&x| println!("{}", x));  // 警告:未使用的 map
    
    // 正确做法:
    nums.iter().for_each(|&x| println!("  {}", x));
}

基本示例 ​

用 map 构建一个数据转换管道:

rust
#[derive(Debug)]
struct RawRecord {
    name: String,
    score_str: String,
    grade_str: String,
}

#[derive(Debug)]
struct ProcessedRecord {
    name: String,
    score: f64,
    grade: char,
    passed: bool,
}

impl RawRecord {
    fn new(name: &str, score: &str, grade: &str) -> Self {
        RawRecord {
            name: name.to_string(),
            score_str: score.to_string(),
            grade_str: grade.to_string(),
        }
    }
}

fn main() {
    // 原始数据
    let raw_data = vec![
        RawRecord::new("张三", "92.5", "A"),
        RawRecord::new("李四", "78.0", "B"),
        RawRecord::new("王五", "55.0", "D"),
        RawRecord::new("赵六", "88.5", "A"),
        RawRecord::new("钱七", "63.0", "C"),
    ];

    // 用 map 转换数据格式
    let processed: Vec<ProcessedRecord> = raw_data.into_iter()
        .map(|raw| {
            let score = raw.score_str.parse::<f64>().unwrap_or(0.0);
            let grade = raw.grade_str.chars().next().unwrap_or('?');
            ProcessedRecord {
                name: raw.name,
                score,
                grade,
                passed: score >= 60.0,
            }
        })
        .collect();

    // 显示处理后的数据
    println!("=== 处理后的记录 ===");
    for record in &processed {
        let status = if record.passed { "通过" } else { "未通过" };
        println!("  {} | {:.1}分 | {}级 | {}",
            record.name, record.score, record.grade, status);
    }

    // 进一步用 map 做统计变换
    let score_summary: Vec<String> = processed.iter()
        .map(|r| format!("{}:{:.0}", r.name, r.score))
        .collect();
    println!("\n成绩概要: {}", score_summary.join(", "));

    // map 计算排名
    let mut sorted = processed;
    sorted.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap());

    let ranking: Vec<String> = sorted.iter()
        .enumerate()
        .map(|(i, r)| format!("第{}名: {} ({:.1}分)", i + 1, r.name, r.score))
        .collect();

    println!("\n排名:");
    for rank in &ranking {
        println!("  {}", rank);
    }
}

常见问题 ​

问题一:map 会改变元素数量吗?

不会。map 是一对一的转换,输入 N 个元素,输出 N 个元素。如果需要过滤(减少数量),用 filter;如果需要展开(增加数量),用 flat_map。

问题二:map 闭包中可以用 ? 运算符吗?

不能直接用。map 闭包的返回值就是新迭代器的元素,? 需要函数返回 Result。可以在 map 中返回 Result,然后用 collect::<Result<Vec<_>, _>>() 收集。

问题三:map 和 for 循环手动 push 有什么区别?

功能等价,但 map 更声明式、更简洁。map 还能利用迭代器的惰性优化(如和 take 配合只处理前 N 个)。手动 push 更灵活但代码更长。

问题四:连续多个 map 会有性能问题吗?

不会。Rust 编译器会把连续的 map 融合成一次遍历(零成本抽象)。a.map(f).map(g) 在编译后和 a.map(|x| g(f(x))) 性能相同。

适用场景 ​

  • 类型转换:将一种类型的集合转为另一种
  • 数据提取:从结构体中提取特定字段
  • 格式化:将数据转为显示格式
  • 数学运算:对数值集合统一变换

注意事项 ​

  • map 是惰性的,必须用消费器驱动
  • map 不改变元素数量
  • 不要用 map 做纯副作用操作(用 for_each)
  • 连续 map 会被编译器优化,不影响性能
  • map 闭包可以改变元素类型
  • 忘记 collect 是常见错误——map 本身不会执行

总结 ​

map() 是迭代器最基础的适配器,接受闭包对每个元素做一对一转换,产出新的迭代器。map 是惰性的,不会立即执行,需要消费器(collect、sum、for_each)驱动。map 不改变元素数量,但可以改变元素类型。多个 map 链式调用会被编译器优化为一次遍历。map 用于数据转换,不应用于纯副作用操作(那是 for_each 的职责)。在实际项目中,map 常与 filter、collect、enumerate 等方法配合使用,构成声明式的数据处理管道。