rust iterator

1. 如何创建迭代器

在 Rust 中，可以通过以下几种方式创建迭代器：

1. 集合的迭代器：

   • 数组和切片：

     let arr = [1, 2, 3, 4];
     let iter = arr.iter();
     let iter_mut = arr.iter_mut();
     

   • 向量（Vec）：

     let vec = vec![1, 2, 3, 4];
     let iter = vec.iter();
     let iter_mut = vec.iter_mut();
     let into_iter = vec.into_iter();
     

   • HashMap：

     use std::collections::HashMap;
     
     let mut map = HashMap::new();
     map.insert("a", 1);
     map.insert("b", 2);
     
     let iter = map.iter();
     let iter_mut = map.iter_mut();
     let into_iter = map.into_iter();
     

2. 创建自定义迭代器：

   • 实现 Iterator trait：

     struct Counter {
         count: u32,
     }
     
     impl Counter {
         fn new() -> Counter {
             Counter { count: 0 }
         }
     }
     
     impl Iterator for Counter {
         type Item = u32;
     
         fn next(&mut self) -> Option<Self::Item> {
             self.count += 1;
             if self.count < 6 {
                 Some(self.count)
             } else {
                 None
             }
         }
     }
     
     let mut counter = Counter::new();
     while let Some(num) = counter.next() {
         println!("{}", num);
     }
     

3. 创建从范围的迭代器：

   let range = 1..5;
   let inclusive_range = 1..=5;
   
   for i in range {
       println!("{}", i);
   }
   

2. 常用的迭代器方法

1. 基本方法：

   • next(): 返回迭代器的下一个元素。

     let arr = [1, 2, 3];
     let mut iter = arr.iter();
     
     assert_eq!(iter.next(), Some(&1));
     assert_eq!(iter.next(), Some(&2));
     assert_eq!(iter.next(), Some(&3));
     assert_eq!(iter.next(), None);
     

2. 转换方法：

   • map(): 对每个元素进行转换。

     let arr = [1, 2, 3];
     let iter = arr.iter().map(|x| x + 1);
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![2, 3, 4]);
     

   • filter(): 过滤满足条件的元素。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter().filter(|&&x| x % 2 == 0);
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![&2, &4]);
     

   • take(): 获取前 n 个元素。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter().take(2);
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![&1, &2]);
     

   • skip(): 跳过前 n 个元素。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter().skip(2);
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![&3, &4]);
     

3. 消耗方法：

   • count(): 计算迭代器中的元素数量。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter();
     
     assert_eq!(iter.count(), 4);
     

   • sum(): 求和。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter();
     
     assert_eq!(iter.sum::<i32>(), 10);
     

   • product(): 计算乘积。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter();
     
     assert_eq!(iter.product::<i32>(), 24);
     

   • collect(): 收集迭代器的元素到集合中。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter();
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![&1, &2, &3, &4]);
     

4. 适配器方法：

   • chain(): 将两个迭代器连接在一起。

     let arr1 = [1, 2];
     let arr2 = [3, 4];
     let iter = arr1.iter().chain(arr2.iter());
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![&1, &2, &3, &4]);
     

   • zip(): 将两个迭代器配对。

     let arr1 = [1, 2];
     let arr2 = ["a", "b"];
     let iter = arr1.iter().zip(arr2.iter());
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![(&1, &"a"), (&2, &"b")]);
     

   • enumerate(): 为每个元素加上索引。

     let arr = [1, 2, 3];
     let iter = arr.iter().enumerate();
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![(0, &1), (1, &2), (2, &3)]);
     

5. 组合方法：

   • flat_map(): 扁平化嵌套迭代器。

     let arr = [vec![1, 2], vec![3, 4]];
     let iter = arr.iter().flat_map(|v| v.iter());
     
     let result: Vec<_> = iter.collect();
     assert_eq!(result, vec![&1, &2, &3, &4]);
     

   • fold(): 折叠操作，将迭代器中的所有元素结合为一个值。

     let arr = [1, 2, 3, 4];
     let iter = arr.iter();
     
     let result = iter.fold(0, |acc, &x| acc + x);
     assert_eq!(result, 10);
     

示例代码

use std::collections::HashMap;

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum Progress {
    Complete,
    InProgress,
    None,
}

fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
    collection
        .iter()
        .flat_map(|map| map.values())
        .filter(|&&val| val == value)
        .count()
}

fn main() {
    let mut map1 = HashMap::new();
    map1.insert("variables1".to_string(), Progress::Complete);
    map1.insert("from_str".to_string(), Progress::None);

    let mut map2 = HashMap::new();
    map2.insert("variables2".to_string(), Progress::Complete);
    map2.insert("move".to_string(), Progress::Complete);

    let collection = vec![map1, map2];

    let count = count_collection_iterator(&collection, Progress::Complete);
    println!("Number of Complete progress: {}", count);
}