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() 配合在集合前后插入元素。典型应用场景包括合并多个数据源、构建优先级队列、分段数据串联等。