collect 收集器
核心概念
collect() 是迭代器最常用的消费器之一,它将迭代器中的所有元素收集到一个集合类型中。collect() 的强大之处在于它可以根据目标类型自动选择收集方式——同一个迭代器可以收集成 Vec、HashSet、HashMap、String、Result 等不同类型。collect() 通过 FromIterator trait 实现,任何实现了 FromIterator 的类型都可以作为 collect 的目标。由于 collect 可以返回多种类型,通常需要用类型标注告诉编译器目标类型。
fn main() {
let data = vec![1, 2, 3, 4, 5];
// 收集为 Vec
let doubled: Vec<i32> = data.iter().map(|&x| x * 2).collect();
println!("Vec: {:?}", doubled);
// 收集为 HashSet(自动去重)
let nums = vec![1, 2, 2, 3, 3, 3, 4];
let unique: std::collections::HashSet<&i32> = nums.iter().collect();
println!("HashSet: {:?}", unique);
// 收集为 String
let chars = vec!['R', 'u', 's', 't'];
let word: String = chars.iter().collect();
println!("String: {}", word);
// turbofish 语法指定类型
let collected = data.iter().map(|&x| x * 3).collect::<Vec<i32>>();
println!("turbofish: {:?}", collected);
}类型标注的两种方式
fn main() {
let nums = vec![1, 2, 3, 4, 5];
// 方式1:变量类型标注
let result: Vec<i32> = nums.iter().map(|&x| x * 2).collect();
println!("标注: {:?}", result);
// 方式2:turbofish 语法(::<Type>)
let result = nums.iter().map(|&x| x * 2).collect::<Vec<i32>>();
println!("turbofish: {:?}", result);
// 方式3:部分标注(用 _ 让编译器推断元素类型)
let result: Vec<_> = nums.iter().map(|&x| x * 2).collect();
println!("部分标注: {:?}", result);
// 方式4:turbofish 部分标注
let result = nums.iter().map(|&x| x * 2).collect::<Vec<_>>();
println!("turbofish 部分: {:?}", result);
}收集为不同的集合类型
use std::collections::{HashMap, HashSet, BTreeSet, BTreeMap, LinkedList, VecDeque};
fn main() {
let data = vec![3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
// Vec:保持顺序,允许重复
let vec_result: Vec<&i32> = data.iter().collect();
println!("Vec: {:?}", vec_result);
// HashSet:无序,自动去重
let set_result: HashSet<&i32> = data.iter().collect();
println!("HashSet: {:?}", set_result);
// BTreeSet:有序,自动去重
let btree_set: BTreeSet<&i32> = data.iter().collect();
println!("BTreeSet: {:?}", btree_set);
// VecDeque:双端队列
let deque: VecDeque<&i32> = data.iter().collect();
println!("VecDeque: {:?}", deque);
// LinkedList:链表
let list: LinkedList<&i32> = data.iter().collect();
println!("LinkedList: {:?}", list);
// HashMap:从元组迭代器收集
let pairs = vec![("name", "张三"), ("age", "25"), ("city", "北京")];
let map: HashMap<&str, &str> = pairs.into_iter().collect();
println!("HashMap: {:?}", map);
// BTreeMap:有序映射
let entries = vec![(3, "c"), (1, "a"), (2, "b")];
let btree_map: BTreeMap<i32, &str> = entries.into_iter().collect();
println!("BTreeMap: {:?}", btree_map);
// String:从 char 迭代器收集
let greeting: String = "hello".chars()
.map(|c| c.to_uppercase().next().unwrap())
.collect();
println!("String: {}", greeting);
}collect 收集 Result
collect 可以将 Iterator<Item = Result<T, E>> 收集为 Result<Vec<T>, E>。如果所有元素都是 Ok,返回 Ok(Vec<T>);如果有任何一个 Err,立即返回第一个 Err。
fn main() {
// 全部成功
let strings = vec!["1", "2", "3", "4", "5"];
let numbers: Result<Vec<i32>, _> = strings.iter()
.map(|s| s.parse::<i32>())
.collect();
println!("全部成功: {:?}", numbers); // Ok([1, 2, 3, 4, 5])
// 有一个失败
let mixed = vec!["1", "abc", "3"];
let result: Result<Vec<i32>, _> = mixed.iter()
.map(|s| s.parse::<i32>())
.collect();
println!("有失败: {:?}", result); // Err(ParseIntError)
// 实际应用:解析配置
let config_lines = vec![
"timeout=30",
"retries=3",
"port=8080",
];
let config: Result<HashMap<String, String>, String> = config_lines.iter()
.map(|line| {
let parts: Vec<&str> = line.splitn(2, '=').collect();
if parts.len() == 2 {
Ok((parts[0].to_string(), parts[1].to_string()))
} else {
Err(format!("无效配置行: {}", line))
}
})
.collect();
use std::collections::HashMap;
println!("配置: {:?}", config);
}collect 收集 Option
fn main() {
// Iterator<Item = Option<T>> → Option<Vec<T>>
let maybe_nums: Vec<Option<i32>> = vec![Some(1), Some(2), Some(3)];
let collected: Option<Vec<i32>> = maybe_nums.into_iter().collect();
println!("全部 Some: {:?}", collected); // Some([1, 2, 3])
let with_none: Vec<Option<i32>> = vec![Some(1), None, Some(3)];
let collected: Option<Vec<i32>> = with_none.into_iter().collect();
println!("有 None: {:?}", collected); // None
// 实际应用:查找所有匹配项
let names = vec!["Alice", "Bob", "Charlie"];
let indices: Option<Vec<usize>> = vec!["Alice", "Charlie"]
.iter()
.map(|&target| names.iter().position(|&n| n == target))
.collect();
println!("索引: {:?}", indices); // Some([0, 2])
}基本示例
用 collect 构建一个数据转换管道:
use std::collections::HashMap;
#[derive(Debug)]
struct Order {
id: u32,
customer: String,
amount: f64,
status: String,
}
impl Order {
fn new(id: u32, customer: &str, amount: f64, status: &str) -> Self {
Order {
id,
customer: customer.to_string(),
amount,
status: status.to_string(),
}
}
}
fn main() {
let orders = vec![
Order::new(1, "张三", 150.0, "已完成"),
Order::new(2, "李四", 280.0, "已完成"),
Order::new(3, "张三", 90.0, "已取消"),
Order::new(4, "王五", 420.0, "已完成"),
Order::new(5, "李四", 60.0, "进行中"),
Order::new(6, "张三", 310.0, "已完成"),
Order::new(7, "赵六", 175.0, "已完成"),
Order::new(8, "王五", 95.0, "已取消"),
];
// 收集已完成订单的金额
let completed_amounts: Vec<f64> = orders.iter()
.filter(|o| o.status == "已完成")
.map(|o| o.amount)
.collect();
println!("已完成订单金额: {:?}", completed_amounts);
// 收集所有客户名(去重)
let customers: HashSet<&str> = orders.iter()
.map(|o| o.customer.as_str())
.collect();
println!("所有客户: {:?}", customers);
// 按客户分组统计
let by_customer: HashMap<&str, Vec<&Order>> = orders.iter()
.fold(HashMap::new(), |mut map, order| {
map.entry(order.customer.as_str())
.or_insert_with(Vec::new)
.push(order);
map
});
println!("\n按客户分组:");
for (customer, cust_orders) in &by_customer {
let total: f64 = cust_orders.iter().map(|o| o.amount).sum();
println!(" {} ({} 单, 总额 {:.0}):", customer, cust_orders.len(), total);
for o in cust_orders {
println!(" #{} - {:.0} - {}", o.id, o.amount, o.status);
}
}
// 收集为格式化报告
let report: String = orders.iter()
.filter(|o| o.status == "已完成")
.map(|o| format!("#{}: {} ¥{:.0}", o.id, o.customer, o.amount))
.collect::<Vec<_>>()
.join("\n");
println!("\n已完成订单报告:\n{}", report);
// 收集 ID → 订单映射
let order_map: HashMap<u32, &Order> = orders.iter()
.map(|o| (o.id, o))
.collect();
if let Some(order) = order_map.get(&4) {
println!("\n订单 #4: {} - ¥{:.0}", order.customer, order.amount);
}
// unzip:将元组迭代器拆分为两个集合
let (ids, amounts): (Vec<u32>, Vec<f64>) = orders.iter()
.filter(|o| o.status == "已完成")
.map(|o| (o.id, o.amount))
.unzip();
println!("\nIDs: {:?}", ids);
println!("Amounts: {:?}", amounts);
}常见问题
问题一:为什么 collect 需要类型标注?
collect 可以收集为多种集合类型(Vec、HashSet、HashMap 等),编译器无法确定你想要哪种。类型标注告诉编译器目标类型。可以用完整标注 Vec<i32> 或部分标注 Vec<_>。
问题二:collect 和 for 循环手动 push 有什么区别?
功能等价。collect 更简洁、更函数式。collect 还可以预分配内存(通过 size_hint),可能比手动 push 更高效。
问题三:collect 收集 Result 时遇到第一个 Err 就停止吗?
是的。collect::<Result<Vec<T>, E>>() 遇到第一个 Err 就立即返回该错误,不会继续处理后续元素。
问题四:如何收集为 HashMap?
迭代器元素必须是 (K, V) 元组。用 map(|x| (key, value)) 转换后再 collect::<HashMap<K, V>>()。如果有重复键,后面的值会覆盖前面的。
适用场景
- 类型转换:将迭代器结果收集为特定集合
- 去重:收集为
HashSet或BTreeSet - 分组映射:收集为
HashMap - 错误聚合:收集
Result或Option迭代器 - 字符串构建:从
char或&str迭代器收集
注意事项
collect是消费器,调用后迭代器被消耗- 通常需要类型标注或 turbofish 语法指定目标类型
- 部分标注
Vec<_>可以让编译器推断元素类型 collect::<Result<Vec<_>, _>>()遇到第一个错误立即返回- 收集为
HashMap时重复键会被覆盖 collect底层通过FromIteratortrait 实现
总结
collect() 将迭代器中的所有元素收集到目标集合中,是迭代器最常用的消费器之一。它可以收集为 Vec、HashSet、HashMap、BTreeSet、String 等实现了 FromIterator 的类型。由于可以收集为多种类型,通常需要类型标注(let v: Vec<_> = ...collect() 或 collect::<Vec<_>>())。特别有用的是 collect::<Result<Vec<T>, E>>(),可以将 Result 迭代器收集为单个 Result,遇到第一个错误立即返回。收集为 HashMap 需要元素是 (K, V) 元组。