collect 收集器 ​

核心概念 ​

collect() 是迭代器最常用的消费器之一,它将迭代器中的所有元素收集到一个集合类型中。collect() 的强大之处在于它可以根据目标类型自动选择收集方式——同一个迭代器可以收集成 Vec、HashSet、HashMap、String、Result 等不同类型。collect() 通过 FromIterator trait 实现,任何实现了 FromIterator 的类型都可以作为 collect 的目标。由于 collect 可以返回多种类型,通常需要用类型标注告诉编译器目标类型。

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

类型标注的两种方式 ​

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

收集为不同的集合类型 ​

rust
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。

rust
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 ​

rust
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 构建一个数据转换管道:

rust
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 底层通过 FromIterator trait 实现

总结 ​

collect() 将迭代器中的所有元素收集到目标集合中,是迭代器最常用的消费器之一。它可以收集为 Vec、HashSet、HashMap、BTreeSet、String 等实现了 FromIterator 的类型。由于可以收集为多种类型,通常需要类型标注(let v: Vec<_> = ...collect() 或 collect::<Vec<_>>())。特别有用的是 collect::<Result<Vec<T>, E>>(),可以将 Result 迭代器收集为单个 Result,遇到第一个错误立即返回。收集为 HashMap 需要元素是 (K, V) 元组。