迭代器

构造

use std::slice::Iter;
use std::iter::Iterator;
// 数组构造
let it = [1,2,3,4].iter();
// 向量构造
let it = vec![5; 3].iter();
// 可修改构造
let it = vec![5; 3].iter_mut();

合并

// chain()将两个迭代器顺序拼接合并,后续有例子,可拼接成无限多个
let it = (0..10).chain(20..30);
// 0~9~20~29

元组生成

zip() 将2个迭代器合并为一对一元组迭代器

let it = [1,3,5].iter().zip([2,4,6].iter());
assert_eq!(vec![(&1,&2),(&3,&4),(&5,&6)], it.collect::<Vec<(,)>>());
assert_eq!(vec![(0,'f'),(1,'o'),(2,'o')], (0..).zip("foo".chars()).collect::<Vec<_>>());
// 计算2个等长字符串中相同位置上字符不同的个数
let s1 = "amily";
let s2 = "emily";
let diff = s1.chars().zip(s2.chars()).filter(|x|x.0 != x.1).count();
println!("{diff}");//1

案例

let a = [1,2,3].iter();
let b = ['a', 'b', 'c', 'd'].iter();
let x = a.zip(b);
//(1, 'a')(2, 'b')(3, 'c'),会忽略 'd'
for c in x {
    print!("{:?}", c);
}
// 如果三个合并
let a = [1, 2, 3].iter();
let b = ['a', 'b', 'c', 'd'].iter();
let c = [1, 2, 3].iter();
let x = a.zip(b).zip(c);
//(1, ('a', 1))(2, ('b', 2))(3, ('c', 3))
for c in x {
    print!("{:?}", c);
}

遍历

while-next 模式

let mut iter = [1,2,3,4,5].iter();
// 输出：1 2 3 4 5 
// Some(x) 不为空就一直循环
while let Some(x) = iter.next() {
    print!("{:?} ", x);
}

for-in 模式

let it = 0..10;//[0,9]
// for-in循环对迭代器进行遍历
for i in it {
    print!("{} ", i);
}
// 无限循环
for i in 0..{
}

for_each 模式

// for_each()对元素逐个处理，内部调用的是fold()，
// fold()在后面有解释其用法
(1..=3).for_each(|x| {
    print!("{x} ");//1 2 3 
});

案例

遍历切片

let full_slice: &[i32] = &nums1[..];
println!("{:?}", full_slice);// 完整切片
// 对切片类型，还可以进行切片
println!("{:?}", &full_slice[1..3]);// [2,3]
println!("{:?}", &&nums1[0..4][1..3]);// [2,3]
println!("{:?}", &nums1[0..2]);// [1,2]
println!("{:?}", &nums1[2..]);// [3,4,5,6]
println!("{:?}", &nums1[1..nums1.len()-1]);// [2,3,4,5]

let x = [1, 2, 3, 4, 5, 6];
let y = &x[0..3];
println!("{:?}", y);//[1, 2, 3]
let y = &x[0..=3];
println!("{:?}", y);//[1, 2, 3, 4]

//b开头的字符串，在编译器看来就是u8数组的引用
let x: &[u8; 11] = b"Hello World";
for c in x {
    // c是&u8类型，即u8的引用类型
    // 这里将c解引用后的u8类型转为char类型
    print!("{} ", *c as char);
}
println!();
// u8数组的切片
let x_slice1 = &x[0..2];
println!("{:?}", x_slice1);//[72, 101]

遍历数组

// 1.
for i in 0..nums1.len() {
    println!("{} ", nums1[i]);
}
// 2.
for (pos, v) in nums1.iter().enumerate() {
    println!("nums[{}]={}", pos, v);
}
// 3.
for num in nums1 {
    print!("{} ", num);
}

下一个元素

next() 可多次调用，一次取出一个值，直至返回None。调用一次,迭代里中就会少一个元素。

// next()方法取得迭代器中下一个元素
let mut it = 1..3;
assert_eq!(Some(1), it.next());
assert_eq!(Some(2), it.next());
assert_eq!(None, it.next());

提取前几个元素

take(k)取前面k个元素，只可调用一次 迭代器调用take()后，迭代器的所有权会被转移到take方法内部，因此一个迭代器的take方法只能调用一次。

使用后该迭代器不能再使用,所有权已经转移到 take 函数内部。

assert_eq!(vec![1,2,3], (1..10).take(3).collect::<Vec<_>>());

指定开始位

nth(k)

取得迭代器剩余元素中第k个位置的元素，位置从0开始；之后，迭代器跳转到下一个位置。

let mut it = [1, 2, 3].iter();
assert_eq!(Some(&1), it.nth(0));
assert_eq!(Some(&2), it.nth(0));
assert_eq!(Some(&3), it.nth(0));
assert_eq!(None, it.nth(0));
assert_eq!(Some(3), (0..4).nth(3));

获取最后一个元素

last()

只取最后一个元素，只能调用一次。所有权已经转移。

assert_eq!((1..4).last(), Some(3));

反转

//反向遍历
println!("{:?}", "-".repeat(10));
//输出：4,3,2,1,0,
vec![0, 1, 2, 3, 4].iter().rev().for_each(|x|print!("{x},"));
println!();
//输出：9,8,7,6,5,4,3,2,1,0,
for i in (0..10).rev() {
    print!("{:?},", i);
}
println!("\n{:?}", "-".repeat(10));

跳过

skip(k)跳过k个元素

assert_eq!(vec![2,3], (0..4).skip(2).collect::<Vec<_>>());

间隔步长

step_by(k)，从第一个元素开始，每k个取一个出来

//0 2 4 6 8 10 
(0..=10).step_by(2).for_each(|x| print!("{x} "));
assert_eq!(vec![0,2,4,6], (0..7).step_by(2).collect::<Vec<_>>());

顺序合并

chain() 方法对迭代器进行顺序拼接合并

let it = (0..5).chain(15..20);
//[0, 1, 2, 3, 4, 15, 16, 17, 18, 19]
println!("{:?}", it.collect::<Vec<_>>());

映射

map()方法，对迭代器中每一个元素进行映射

格式

map(|item|{})

案例

assert_eq!(vec![0,1,4,9,16], (0..5).map(|x|x*x).collect::<Vec<_>>());

求值

max()
min()
count()
sum()

案例

//最大值
assert_eq!([1,2,3].iter().max(), Some(&3));
//最小值
assert_eq!([1,2,3].iter().min(), Some(&1));
// count()计算迭代器中元素的个数
assert_eq!([1,2,3].iter().count(), 3);
// 求和
assert_eq!([1,2,3].iter().sum::<i32>(), 6);

过滤

过滤数据。接受一个闭包并为迭代器中的每个元素调用该闭包。如果闭包返回true，则元素将包含在新的迭代器中。 对迭代器中的元素进行“过滤”，只留下满足条件的元素；

格式

iter.filter(|x| 与x相关的条件,这里返回一个bool值)
// x : 项

案例

let list2: Vec<_> = (1..=100).filter(|i| i%3 == 0).collect();
assert_eq!(list1, list2);

过滤与映射

filter_map(|item|{})

案例

filter + map的组合。

let s = "1 a 2 b 3 c";
let a = s.split_ascii_whitespace().filter_map(|x|x.parse::<i32>().ok()).collect::<Vec<i32>>();
//[1, 2, 3]
println!("{:?}", a);

收集

方法负责将迭代器中的元素按顺序收集到一个集合容器中。

collect()

全量校验

判断迭代器中是否所有元素都符合闭包predicate指定的测试。

格式

all(|item| item==&x)

案例

let b = (2..10).into_iter().all(|i|i>0);
println!("{}", b);//true

累加器

fold()方法，通过传入一个初始值和一个闭包累加器，对迭代器中的每一个元素依次进行处理并“累加”，最后返回“累加”结果。这里用“累加”来指代函数操作，并不仅仅是能做加法。

格式

fold(初始值,|acc,item|{ return acc });
// acc : 累积值
// x : 迭代项
// 返回值 : acc
// 闭包内返回值 : 直接返回给acc

案例

// 案例一
assert_eq!(3, (1..3).fold(0, |acc, x|acc+x));//1+2
assert_eq!(6, (1..3).fold(0, |acc, x|acc+2*x));//2*1 + 2*2
// 案例二
println!("{:?}", a.fold(0, |mut acc, item| {
    acc + item
}));