13.迭代器.rs

妖狐艹你老母 2022-10-23 11:23 134阅读 0赞

/*
    在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);
    }