迭代器

let sum: i32 = nums.iter()
    .filter(|&&n| n % 2 == 0) // 留下偶数
    .map(|&n| n * n)          // 每个平方
    .sum();                   // 求和

let iter = nums.iter().map(|&n| {
    println!("处理 {n}"); // 此刻不会执行!
    n * 2
});
// 上面什么都没打印,因为还没有消费器

let result: Vec<i32> = iter.collect(); // 此刻才逐元素执行 map

let names = vec![String::from("a"), String::from("b")];
let upper: Vec<String> = names.into_iter()
    .map(|s| s.to_uppercase()) // s 是 String 本身,可随意消费
    .collect();
// names 已被消耗,这里不能再用

let v = vec![10, 20, 30, 40, 50];

// enumerate: 为每个元素附上索引 (usize)
let indexed: Vec<_> = v.iter().enumerate().collect();
// [(0, &10), (1, &20), (2, &30), (3, &40), (4, &50)]

// zip: 将两个迭代器逐对拉链,较短的耗尽即停
let names = vec!["a", "b", "c"];
let paired: Vec<_> = v.iter().zip(names.iter()).collect();
// [(&10, &"a"), (&20, &"b"), (&30, &"c")]  ← 40,50 被丢弃

// take / skip: 截取前 n 个 / 跳过前 n 个
let first3: Vec<_> = v.iter().take(3).collect();  // [&10, &20, &30]
let tail: Vec<_>   = v.iter().skip(2).collect();  // [&30, &40, &50]
// 天生一对 = 分页: v.iter().skip(offset).take(page_size)

// cloned / copied: 把 &T → T,省去 map(|&x| x) 的模式解引用
let squares: Vec<i32> = v.iter().cloned().map(|x| x * x).collect();
// copied 用于 Copy 类型(i32 等),cloned 用于 Clone 类型(String 等)

// sum / product: 累加或累乘
let total: i32 = v.iter().sum();            // 150
let factorial = (1..=5).product::<i32>();  // 120

// count: 计数,比 .collect::<Vec<_>>().len() 少一次堆分配
let how_many = v.iter().filter(|&&x| x > 25).count(); // 3

// fold: 带初值的聚合."手里拿个篮子,逐个装元素,最后返回篮子"
let sum  = v.iter().fold(0, |acc, &x| acc + x);       // 求和:150
let prod = v.iter().fold(1, |acc, &x| acc * x);       // 求积:120
let max  = v.iter().fold(i32::MIN, |acc, &x| acc.max(x)); // 最大值:50

// 复杂例子:用 fold 把数字拼成逗号分隔字符串
let csv = v.iter().fold(String::new(), |mut acc, x| {
    if !acc.is_empty() { acc.push(','); }
    acc.push_str(&x.to_string());
    acc
}); // "10,20,30,40,50"

// for_each: 只做副作用(打印,写文件等),返回 ()
v.iter().for_each(|x| println!("{x}"));

// find: 返回第一个匹配元素,结果是 Option
let first = v.iter().find(|&&x| x > 25); // Some(&30)

// any / all: 存在 / 全称判定
let has_big = v.iter().any(|&&x| x > 100);  // false
let all_pos = v.iter().all(|&&x| x > 0);    // true

// max / min: 极值,空迭代器返回 None
let biggest = v.iter().max(); // Some(&50)

// nth: 跳过前 n 个取下一个,等价于 .skip(n).next()
let third = v.iter().nth(2);  // Some(&30)

fn collect<B: FromIterator<Self::Item>>(self) -> B

let v = vec![1, 2, 3, 4, 5];

// → Vec(最常用)
let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();

// → HashMap: 迭代器元素必须是 (K, V) 对
let names = vec!["a", "b", "c"];
let map: HashMap<_, _> = names.iter().enumerate().map(|(i, &n)| (n, i)).collect();
// {"a": 0, "b": 1, "c": 2}

// → HashSet: 去重
let nums = vec![1, 2, 2, 3, 3, 3];
let unique: HashSet<_> = nums.into_iter().collect(); // {1, 2, 3}

// → String: 元素须为 char 或 &str
let chars = vec!['h', 'e', 'l', 'l', 'o'];
let s: String = chars.iter().collect(); // "hello"

// 方式 1: turbofish(最紧凑)
let v = iter.collect::<Vec<_>>();

// 方式 2: 变量类型标注(最可读,推荐)
let v: Vec<i32> = iter.collect();

// 方式 3: 上下文推断(函数签名,字段类型等)

// 场景:解析一批字符串,要么全成功,要么报第一个错
let inputs = vec!["1", "2", "three", "4"];

// 用 collect 的"翻转"能力:
let all_ok: Result<Vec<i32>, _> = inputs.iter()
    .map(|s| s.parse::<i32>())
    .collect();
// Err(...)  ← 到 "three" 就失败,不产出 Vec

// Option 同理:
let nums = vec![Some(1), Some(2), None, Some(4)];
let all_some: Option<Vec<i32>> = nums.into_iter().collect();
// None ← 碰到 None 就整体返回 None

let names = vec![String::from("a"), String::from("b")];

// into_iter(): 消耗原集合,元素所有权转移 → collect 产出 Vec<String>
let owned: Vec<String> = names.into_iter().collect();
// names 已死

let names = vec![String::from("a"), String::from("b")];

// iter(): 借用元素,collect 产出 Vec<&String>
let borrowed: Vec<&String> = names.iter().collect();
// names 仍可用

// iter().cloned(): 借用遍历,但 clone 出每个元素 → 产出 Vec<String>
let cloned: Vec<String> = names.iter().cloned().collect();
// names 仍可用,cloned 是拥有自己数据的独立集合

// 1. 找到某个元素的位置: enumerate + find + map
let pos = v.iter().enumerate()
    .find(|(_, &x)| x > 25)
    .map(|(i, _)| i); // Some(2),即 30 的索引

// 2. 分页: skip + take
let page = 2; let page_size = 3;
let page_data: Vec<_> = v.iter()
    .skip((page - 1) * page_size)
    .take(page_size)
    .collect(); // [&40, &50]

// 3. 展平嵌套: flatten / flat_map
let nested = vec![vec![1, 2], vec![3, 4, 5]];
let flat: Vec<_> = nested.iter().flatten().collect(); // [&1,&2,&3,&4,&5]
let doubled: Vec<_> = (0..3).flat_map(|x| [x, x * 2]).collect(); // [0,0,1,2,2,4]

// 4. 分组归类: fold + HashMap
use std::collections::HashMap;
let words = vec!["apple", "ant", "banana", "bat"];
let by_first = words.iter().fold(HashMap::new(), |mut map, w| {
    map.entry(w.chars().next().unwrap()).or_insert(vec![]).push(w);
    map
});
// {'a': ["apple","ant"], 'b': ["banana","bat"]}

// 5. filter_map: 同时过滤和映射,返回 Option 的元素自动滤掉 None
let inputs = vec!["1", "two", "3", "four"];
let nums: Vec<i32> = inputs.iter()
    .filter_map(|s| s.parse::<i32>().ok())
    .collect(); // [1, 3]