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