Rust迭代器常用方法

enumerate

普通遍历时迭代器时无法取到迭代器中元素的下标，使用enumerate即可

fn test_iter() {
    let vec = vec![1, 2, 3];
    for (count, num) in vec.into_iter().enumerate() {
        println!("index:{},val:{}", count, num);
    }
}

//输出
index:0,val:1
index:1,val:2
index:2,val:3

filter

filter传入的闭包返回一个bool值，返回true对应的元素将被保留，返回false，对应的元素将被丢弃

fn test_iter() {
    let vec: Vec<i32> = vec![1,2,3];
    let new_vec: Vec<i32> = vec.into_iter().filter(|n| { n%2 == 0 }).collect();
    println!("vec:{:?}",new_vec);
}
//输出
vec:[2]

filter_map

filter_map 不仅可以过滤元素，同时也可以对元素做处理，并生成新的元素。传入的闭包返回一个Option<T>，如果返回Some(val) ，val将被保留，如果返回None，对应的元素将被丢弃。

pub fn test_iter() {
    let vec: Vec<i32> = vec![1, 2, 3];
    let new_vec: Vec<i32> = vec
        .into_iter()
        .filter_map(|n| if n % 2 == 0 { Some(n+10) } else { None })
        .collect();
    println!("new_vec:{:?}", new_vec);
}
//输出
new_vec:[12]

补充：为什么有了filter还需要filter_map，见名知义，filter更多是过滤元素，而filter_map是对元素过滤+修改。

map

map对于迭代器中的每个元素，都会应用传入的闭包，并生成新的元素

fn test_iter() {
    let vec: Vec<i32> = vec![1,2,3];
    let new_vec:Vec<i32> = vec.into_iter().map(|n| n * 2 ).collect();
    println!("new_vec:{:?}",new_vec); 
}
//输出
new_vec:[2, 4, 6]

flatten

flatten可以将迭代器中嵌套的迭代器“拍平”到一个迭代器中

fn test_iter() {
    let vec: Vec<Vec<i32>> = vec![vec![1, 2, 3], vec![4, 5, 6]];
    let new_vec: Vec<i32> = vec
        .into_iter()
        .flatten()
        .collect();
    println!("new_vec:{:?}",new_vec);
}
//输出
new_vec:[1, 2, 3, 4, 5, 6]

flat_map

可以将 flat_map 看做等效于 .map().flatten() 的处理

flat_map传入的闭包返回一个迭代器，返回的所有迭代器被“拍平”到一个迭代器中，与map及filter_map主要区别如下：

1. 闭包返回的元素需要可迭代
2. 闭包返回的可迭代的元素将被“拍平”到一个迭代器中

fn test_iter() {
    let vec: Vec<Vec<i32>> = vec![vec![1, 2, 3], vec![4, 5, 6, 7], vec![8, 9, 10, 11]];
    let new_vec = vec
        .into_iter()
        .flat_map(|item| if item.len()<3 {item} else {vec![]} );
    for item in new_vec {
        println!("{}",item);
    }
}

//输出
1
2
3

zip

将两个迭代器按对应下标的元素组合在一起，并返回新的迭代器。

fn test_iter() {
    let vec1: Vec<i32> = vec![1, 2, 3];
    let vec2: Vec<i32> = vec![4, 5, 6];
    let new_vec = vec1.into_iter().zip(vec2);
    for (v1,v2) in new_vec {
        println!("v1:{},v2:{}",v1,v2);
    }
}
//输出
v1:1,v2:4
v1:2,v2:5
v1:3,v2:6

chain

可以简单理解为将两个迭代器链接在一起。

fn test_iter() {
    let vec1: Vec<i32> = vec![1, 2, 3];
    let vec2: Vec<i32> = vec![4, 5, 6];
    let new_vec: Vec<i32> = vec1.into_iter().chain(vec2).collect();
    println!("new_vec:{:?}",new_vec);
}
//输出
new_vec:[1, 2, 3, 4, 5, 6]