"首次提交"

iterator_learn/.gitignore

@@ -0,0 +1 @@
+/target

iterator_learn/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "iterator_learn"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

iterator_learn/src/main.rs

@@ -0,0 +1,176 @@
+use std::{env::VarsOs, path::Iter};
+
+fn main() {
+    iterator_learn();
+}
+
+fn iterator_learn() {
+    let v1 = vec![1, 2, 3];
+    let iter = v1.iter();
+    //使用循环遍历迭代器
+    for it in iter {
+        println!("{}", it);
+    }
+    //使用next方法遍历迭代器，
+    let mut iter = v1.iter();
+    loop {
+        let item = match iter.next() {
+            Some(it) => it,
+            None => break,
+        };
+        println!("{}", item)
+    }
+
+    let ret = v1.iter().skip(1);
+    for it in ret {
+        println!("{}", it);
+    }
+}
+
+#[test]
+fn iterator_demonstration() {
+    let v1 = vec![1, 2, 3];
+
+    // next 方法 会获得所有权。必须将其变为mut
+    let mut iter = v1.iter();
+
+    assert_eq!(iter.next(), Some(1).as_ref());
+    assert_eq!(iter.next(), Some(2).as_ref());
+    assert_eq!(iter.next(), Some(3).as_ref());
+    assert_eq!(iter.next(), None);
+}
+#[test]
+fn iterator_create1() {
+    let v1 = vec![1, 2, 3];
+
+    let mut iter = v1.iter().map(|x| x + 1);
+    assert_eq!(iter.next(), Some(2));
+    assert_eq!(iter.next(), Some(3));
+    assert_eq!(iter.next(), Some(4));
+    assert_eq!(iter.next(), None);
+
+    // collect 方法返回值需要手动指定。以便于rust编译推断其所需构造的类型
+    let ret: Vec<i32> = v1.iter().map(|x| x + 1).collect();
+    assert_eq!(vec![2, 3, 4], ret);
+}
+
+#[test]
+fn closure_test() {
+    let mut offset = 10;
+    //闭包可以手动指定类型也可以自动推断，但是一旦确定一种调用方法后将不能再改变参数类型
+    let func = |x: i32, y, z| -> i32 { x + y + z + offset };
+
+    fn sub_fun<F>(func: F, x: i32, y: i32, z: i32) -> i32
+    where
+        F: Fn(i32, i32, i32) -> i32,
+    {
+        func(x, y, z)
+    }
+    //offset = 20; // 不可以修改offset的值，因为其已经被闭包作为一个一个不可变引用使用了，
+    assert_eq!(sub_fun(func, 1, 2, 3), 6 + offset);
+
+    //闭包的生命周期已经结束，所以offset可以被修改了
+    offset = 20;
+    assert_eq!(offset, 20);
+}
+
+#[test]
+fn filter_by_size() {
+    #[derive(PartialEq, Debug)]
+    struct Shoe {
+        size: u32,
+        style: String,
+    }
+    fn shoes_in_my_size(shoes: Vec<Shoe>, size: u32) -> Vec<Shoe> {
+        //into_iter 方法会获得shoes的所有权，所以不能再使用shoes
+        shoes.into_iter().filter(|x| size == x.size).collect()
+    }
+    let shoes = vec![
+        Shoe {
+            size: 10,
+            style: String::from("sneaker"),
+        },
+        Shoe {
+            size: 13,
+            style: String::from("sandal"),
+        },
+        Shoe {
+            size: 10,
+            style: String::from("boot"),
+        },
+    ];
+
+    let ret = shoes_in_my_size(shoes, 10);
+    //不可以再使用shoes，所有权已经到了 shoes_in_my_size 里面
+    // shoes.push(Shoe {
+    //     size: 10,
+    //     style: String::from("sneaker"),
+    // });
+    assert_eq!(
+        vec![
+            Shoe {
+                size: 10,
+                style: String::from("sneaker"),
+            },
+            Shoe {
+                size: 10,
+                style: String::from("boot"),
+            },
+        ],
+        ret
+    );
+}
+
+struct Counter {
+    cnt: u32,
+}
+
+impl Counter {
+    fn new() -> Counter {
+        Counter { cnt: 0 }
+    }
+}
+
+impl Iterator for Counter {
+    type Item = u32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.cnt < 5 {
+            self.cnt += 1;
+            Some(self.cnt)
+        } else {
+            None
+        }
+    }
+}
+
+#[test]
+fn custom_iterator() {
+    let mut count = Counter::new();
+    assert_eq!(count.next(), Some(1));
+    assert_eq!(count.next(), Some(2));
+    assert_eq!(count.next(), Some(3));
+    assert_eq!(count.next(), Some(4));
+    assert_eq!(count.next(), Some(5));
+    assert_eq!(count.next(), None);
+}
+
+#[test]
+fn custom_iterator1() {
+    let count: Vec<(u32, u32)> = Counter::new()
+        .zip(Counter::new().filter(|x| x % 2 == 0))
+        .collect();
+    assert_eq!(count, vec![(1, 2), (2, 4)]);
+    let count: Vec<u32> = Counter::new()
+        .zip(Counter::new().filter(|x| x % 2 == 0))
+        .map(|(a, b)| a + b)
+        .collect();
+
+    assert_eq!(count, vec![3, 6]);
+
+    let count: u32 = Counter::new()
+        .zip(Counter::new().filter(|x| x % 2 == 0))
+        .map(|(a, b)| a + b)
+        .sum();
+    assert_eq!(count, 9 );
+}