chain 链接 ​

核心概念 ​

chain() 将两个迭代器首尾相连,先产出第一个迭代器的所有元素,再产出第二个迭代器的所有元素。chain 是惰性适配器,不会立即执行。两个迭代器必须产出相同类型的元素。chain 不会去重也不会排序,只是简单地串联。它常用于合并多个数据源、在集合前后插入额外元素等场景。

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

    // chain:先产出 first 的元素,再产出 second 的元素
    let combined: Vec<&i32> = first.iter().chain(second.iter()).collect();
    println!("chain: {:?}", combined);  // [1, 2, 3, 4, 5, 6]

    // 等价于合并两个集合,但不需要创建新的 Vec
    // chain 是惰性的,按需产出元素
    for item in first.iter().chain(second.iter()) {
        print!("{} ", item);
    }
    println!();

    // 原始集合不受影响
    println!("first: {:?}", first);
    println!("second: {:?}", second);
}

chain 的惰性行为 ​

rust
fn main() {
    let a = vec![10, 20, 30];
    let b = vec![40, 50, 60];

    // chain 是惰性的,元素按需产出
    let mut iter = a.iter().chain(b.iter());

    // 先从第一个迭代器取
    println!("{:?}", iter.next());  // Some(&10)
    println!("{:?}", iter.next());  // Some(&20)
    println!("{:?}", iter.next());  // Some(&30)

    // 第一个耗尽后,自动从第二个取
    println!("{:?}", iter.next());  // Some(&40)
    println!("{:?}", iter.next());  // Some(&50)
    println!("{:?}", iter.next());  // Some(&60)

    // 两个都耗尽
    println!("{:?}", iter.next());  // None
}

chain 与不同迭代器来源 ​

rust
fn main() {
    // 数组和 Vec
    let arr = [1, 2, 3];
    let vec = vec![4, 5, 6];
    let combined: Vec<&i32> = arr.iter().chain(vec.iter()).collect();
    println!("数组+Vec: {:?}", combined);

    // Range 和 Vec
    let range_data: Vec<i32> = (1..=3).chain(vec![10, 20, 30]).collect();
    println!("Range+Vec: {:?}", range_data);

    // 多个 chain(三个以上)
    let a = vec![1, 2];
    let b = vec![3, 4];
    let c = vec![5, 6];
    let d = vec![7, 8];
    let all: Vec<&i32> = a.iter()
        .chain(b.iter())
        .chain(c.iter())
        .chain(d.iter())
        .collect();
    println!("四路chain: {:?}", all);

    // 空迭代器的 chain
    let empty: Vec<i32> = vec![];
    let result: Vec<&i32> = empty.iter().chain(vec![1, 2, 3].iter()).collect();
    println!("空+非空: {:?}", result);

    // 单个元素 + 集合
    let header = std::iter::once(&0);
    let data = vec![1, 2, 3, 4, 5];
    let with_header: Vec<&&i32> = header.chain(data.iter().map(|x| x)).collect();
    println!("头部+数据: {:?}", with_header);
}

chain 在数据处理中的应用 ​

rust
fn main() {
    // 在集合前后添加元素
    let data = vec![2, 3, 4];
    let with_bounds: Vec<i32> = std::iter::once(0)     // 前面加 0
        .chain(data.into_iter())                        // 原始数据
        .chain(std::iter::once(999))                    // 后面加 999
        .collect();
    println!("加边界: {:?}", with_bounds);

    // 合并多个搜索结果
    let local_results = vec!["本地结果1", "本地结果2"];
    let remote_results = vec!["远程结果1", "远程结果2", "远程结果3"];
    let cached_results = vec!["缓存结果1"];

    let all_results: Vec<&&str> = cached_results.iter()
        .chain(local_results.iter())
        .chain(remote_results.iter())
        .collect();
    println!("合并搜索: {:?}", all_results);

    // 优先级队列:高优先级在前
    let high_priority = vec!["紧急任务A", "紧急任务B"];
    let normal_priority = vec!["普通任务C", "普通任务D", "普通任务E"];
    let low_priority = vec!["低优先级F"];

    println!("\n任务队列:");
    for (i, task) in high_priority.iter()
        .chain(normal_priority.iter())
        .chain(low_priority.iter())
        .enumerate()
    {
        println!("  [{}] {}", i + 1, task);
    }
}

chain 与其他适配器配合 ​

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

    // chain + filter
    let big_nums: Vec<&i32> = nums_a.iter()
        .chain(nums_b.iter())
        .filter(|&&x| x > 5)
        .collect();
    println!("chain+filter(>5): {:?}", big_nums);

    // chain + map
    let formatted: Vec<String> = nums_a.iter()
        .chain(nums_b.iter())
        .map(|&x| format!("#{:02}", x))
        .collect();
    println!("chain+map: {:?}", formatted);

    // chain + sort(需要先 collect 再 sort)
    let mut all: Vec<i32> = nums_a.iter()
        .chain(nums_b.iter())
        .copied()
        .collect();
    all.sort();
    println!("chain+sort: {:?}", all);

    // chain + fold
    let total: i32 = nums_a.iter()
        .chain(nums_b.iter())
        .fold(0, |acc, &x| acc + x);
    println!("chain+fold: {}", total);

    // chain + take
    let first_four: Vec<&i32> = nums_a.iter()
        .chain(nums_b.iter())
        .take(4)
        .collect();
    println!("chain+take(4): {:?}", first_four);

    // chain + enumerate
    println!("\nchain+enumerate:");
    for (i, &num) in nums_a.iter().chain(nums_b.iter()).enumerate() {
        print!("[{}]={} ", i, num);
    }
    println!();
}

基本示例 ​

用 chain 合并多个数据源构建报告:

rust
#[derive(Debug)]
struct Transaction {
    source: String,
    description: String,
    amount: f64,
}

impl Transaction {
    fn new(source: &str, desc: &str, amount: f64) -> Self {
        Transaction {
            source: source.to_string(),
            description: desc.to_string(),
            amount,
        }
    }
}

impl std::fmt::Display for Transaction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let sign = if self.amount >= 0.0 { "+" } else { "" };
        write!(f, "[{}] {} {}{:.2}", self.source, self.description, sign, self.amount)
    }
}

fn main() {
    // 多个来源的交易记录
    let bank_transactions = vec![
        Transaction::new("银行", "工资", 15000.0),
        Transaction::new("银行", "房租", -3000.0),
        Transaction::new("银行", "水电费", -500.0),
    ];

    let alipay_transactions = vec![
        Transaction::new("支付宝", "外卖", -45.0),
        Transaction::new("支付宝", "打车", -25.0),
        Transaction::new("支付宝", "红包收入", 10.0),
    ];

    let wechat_transactions = vec![
        Transaction::new("微信", "转账收入", 200.0),
        Transaction::new("微信", "购物", -150.0),
    ];

    // 用 chain 合并所有交易记录
    let all_transactions: Vec<&Transaction> = bank_transactions.iter()
        .chain(alipay_transactions.iter())
        .chain(wechat_transactions.iter())
        .collect();

    println!("=== 所有交易记录 ({} 条) ===", all_transactions.len());
    for (i, t) in all_transactions.iter().enumerate() {
        println!("  {}. {}", i + 1, t);
    }

    // 统计总收支
    let total_income: f64 = bank_transactions.iter()
        .chain(alipay_transactions.iter())
        .chain(wechat_transactions.iter())
        .filter(|t| t.amount > 0.0)
        .map(|t| t.amount)
        .sum();

    let total_expense: f64 = bank_transactions.iter()
        .chain(alipay_transactions.iter())
        .chain(wechat_transactions.iter())
        .filter(|t| t.amount < 0.0)
        .map(|t| t.amount)
        .sum();

    println!("\n=== 汇总 ===");
    println!("  总收入: +{:.2}", total_income);
    println!("  总支出: {:.2}", total_expense);
    println!("  净额:   {:.2}", total_income + total_expense);

    // 按来源统计
    println!("\n=== 按来源统计 ===");
    for source in &["银行", "支付宝", "微信"] {
        let subtotal: f64 = bank_transactions.iter()
            .chain(alipay_transactions.iter())
            .chain(wechat_transactions.iter())
            .filter(|t| t.source == *source)
            .map(|t| t.amount)
            .sum();
        println!("  {}: {:.2}", source, subtotal);
    }
}

常见问题 ​

问题一:chain 和直接合并 Vec 有什么区别?

chain 是惰性的,不创建新的集合,只在遍历时按需从两个迭代器取元素。合并 Vec(extend/append)会创建新的内存分配。如果只需遍历一次,chain 更节省内存。

问题二:chain 可以连接不同类型的集合吗?

集合类型可以不同(如数组和 Vec),但元素类型必须相同。chain 要求两个迭代器的 Item 类型一致。

问题三:多个 chain 调用会有性能问题吗?

一般不会。编译器会内联优化。但极端情况下(数十个 chain)可能产生较深的类型嵌套,此时可以考虑先 collect 再处理。

问题四:chain 和 flat_map 有什么区别?

chain 是将两个迭代器首尾连接。flat_map 是对每个元素展开为一个迭代器,然后将所有结果连接。chain 连接固定数量的迭代器,flat_map 处理动态数量。

适用场景 ​

  • 多源合并:合并多个数据源的结果
  • 添加边界元素:在集合前后插入哨兵值
  • 优先级队列:按优先级顺序排列多组数据
  • 分段处理:将预处理数据和原始数据串联

注意事项 ​

  • chain 是惰性的,需要消费器驱动
  • 两个迭代器的元素类型必须相同
  • chain 先耗尽第一个迭代器,再处理第二个
  • 多个 chain 可以链式调用
  • chain 不去重、不排序
  • std::iter::once() 常与 chain 配合插入单个元素

总结 ​

chain() 将两个迭代器首尾相连,先产出第一个的全部元素,再产出第二个的全部元素。chain 是惰性的,不创建新集合,按需产出元素。两个迭代器的元素类型必须相同,但集合类型可以不同。多个 chain 可以链式调用来连接三个以上的迭代器。chain 常与 std::iter::once() 配合在集合前后插入元素。典型应用场景包括合并多个数据源、构建优先级队列、分段数据串联等。