map 适配器
核心概念
map() 是迭代器最常用的适配器方法,它接受一个闭包,对迭代器中的每个元素应用这个闭包,产出一个新的迭代器。map() 不会改变元素的数量,只改变元素的值或类型。map() 是惰性的——调用 map() 不会立即执行任何计算,只有在消费器(如 collect、for_each、sum)驱动时才会逐个处理元素。
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 的惰性特性
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 的类型转换
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 与其他适配器链式调用
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 的对比
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 构建一个数据转换管道:
#[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 等方法配合使用,构成声明式的数据处理管道。