13.Iterator.rs

/*
在Rust中，迭代器共分为三个部分：迭代器、适配器、消费者。
_迭代器_给你一个值的序列
_适配器_操作迭代器，产生一个不同输出序列的新迭代器
_消费者_操作迭代器，产生最终值的集合
迭代器本身提供了一个惰性的序列，适配器对这个序列进行诸如筛选、拼接、转换查找等操作，消费者则在前两者的基础上生成最后的数值集合

更多请看
https://blog.csdn.net/guiqulaxi920/article/details/78823541

*/

use std::collections::HashMap;

//迭代器
fn test_1() {
    //(1..10) 其本身是一个迭代器
    for i in 1..10 {
        print!("{}-", i);
    }
    println!("");

    //写法2
    let values = vec![1, 2, 3];
    for x in &values {
        print!("{}-", x);
    }
    println!("");

    //写法3
    let mut v_iter = values.iter();
    loop {
        if let Some(v) = v_iter.next() {
            print!("{}-", v);
        } else {
            break;
        }
    }
    println!("");

    let mut nums = vec![1, 2, 3, 4, 5];
    for i in &mut nums {
        *i *= 2;
    }
    println!("{:?}", nums);

    let nums = vec![1, 2, 3, 4, 5];
    let nums = nums.iter().map(|x| x * 2);
    println!("{:?}", nums);

    //可变迭代
    let mut v3 = vec![1, 2, 3];
    let mut v_iter = v3.iter_mut();
    loop {
        if let Some(v) = v_iter.next() {
            *v += 10;
        } else {
            break;
        }
    }
    println!("{:?}", v3);
}

//适配器
fn test_2() {
    println!("---------------------------test2-----------------------");
    //filter()是一个带有一个闭包参数的适配器
    for i in (1..10).filter(|&x| x % 2 == 0) {
        println!("{}", i);
    }
   
    //又是惰性！那个闭包永远也不会执行。这个例子也不会打印任何数字：
    (1..100).map(|x| println!("{}", x));

    let t = (1..100).map(|x| x + 1000);
    println!("{:?}", t);
}

//消费者
fn test_3() {
    println!("---------------------------test3-----------------------");

    //collect()从迭代器中取得尽可能多的值，然后返回结果的集合
    let one_to_one_hundred1 = (1..101).collect::<Vec<i32>>();
    let one_to_one_hundred2 = (1..101).collect::<Vec<_>>();
    println!("{:?}", one_to_one_hundred2);

    //find接收一个闭包，然后处理迭代器中每个元素的引用。这个闭包返回true如果这个元素是我们要找的，返回false如果不是
    let greater_than_forty_two = (0..100).find(|x| *x > 50);
    println!("{:?}", greater_than_forty_two);

    //fold()看起来像这样：fold(base, |accumulator, element| ...)。它需要两个参数：第一个参数叫做_基数_（base）。第二个是一个闭包，它自己也需要
    //两个参数：第一个叫做_累计数_（accumulator），第二个叫_元素_（element）。每次迭代，这个闭包都会被调用，返回值是下一次迭代的累计数。在我们的第一
    //次迭代，基数是累计数。
    let sum = (1..101).fold(1000000000, |sum, x| sum + x);
    println!("{}", sum);

    let v1 = vec![1, 2, 3, 4];
    let v1_iter = v1.iter();
    let total: i32 = v1_iter.sum();
    println!("{}", total);
}

//定制迭代器
fn test_4() {
    println!("---------------------------test4-----------------------");
    struct Counter {
        count: u32,
    }

    impl Counter {
        fn new() -> Counter {
            Counter { count: 0 }
        }
    }

    //需要实施迭代器特性
    impl Iterator for Counter {
        type Item = u32; //声明迭代器关联类型

        //只需实施next
        fn next(&mut self) -> Option<Self::Item> {
            //需改变自身count
            self.count += 1;

            if self.count < 6 {
                Some(self.count)
            } else {
                None
            }
        }
    }

    let mut counter = Counter::new();

    assert_eq!(counter.next(), Some(1));
    assert_eq!(counter.next(), Some(2));
    assert_eq!(counter.next(), Some(3));
    assert_eq!(counter.next(), Some(4));
    assert_eq!(counter.next(), Some(5));
    assert_eq!(counter.next(), None);
}

//使用闭合函数
fn test_5() {
    println!("---------------------------test5-----------------------");
    let v1: Vec<i32> = vec![1, 2, 3]; //显示声明
    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect(); //转化成集合， 自动推导类型
    assert_eq!(v2, vec![2, 3, 4]);
    println!("{:?}", v2);

    #[derive(PartialEq, Debug)] //衍生属性
    struct Shoe {
        size: u32,
        style: String,
    }
    let shoes = vec![
        Shoe {
            size: 10,
            style: String::from("sneaker"),
        },
        Shoe {
            size: 13,
            style: String::from("sandal"),
        },
        Shoe {
            size: 10,
            style: String::from("boot"),
        },
    ];

    fn shoes_in_my_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
        shoes
            .into_iter() //所有权，需要改变迭代器尺寸
            .filter(|s| s.size == shoe_size) //过滤器，闭合函数读取环境。//python dict comprehension
            .collect()
    }
    let in_my_size = shoes_in_my_size(shoes, 10);
    println!("{:?}", in_my_size);
}

fn main() {
    test_1();
    test_2();
    test_3();
    test_4();
    test_5();

    println!("---------------------------main-----------------------");
    let mut map = HashMap::new();
    map.insert(1, String::from("a"));
    map.insert(2, String::from("b"));
    map.insert(3, String::from("c"));
    let t1 = map.iter().filter(|(k,v)|**k != 1).collect::<Vec<_>>();
    println!("{:?}",t1);
}