迭代与循环
循环
定义：循环是一种控制流结构，它会反复执行一组语句，直到满足某个条件。
控制条件：循环通常包含一个条件表达式，只有在条件为真时，循环体中的语句才会执行。
退出条件：循环执行直到条件不再满足，或者通过break语句显式中断循环。
使用场景：适用于需要反复执行某个操作直到满足某个条件的情况。
迭代
定义：迭代是对序列中的元素进行逐个访问的过程。
控制条件：迭代通常使用迭代器(lterator)来实现，迭代器提供了对序列元素
的访问和操作。
退出条件：通常不需要显式的退出条件，迭代器会在处理完所有元素后自动停止。
使用场景：适用于需要遍历数据结构中的元素的情况，例如数组、切片、集合等。
循环和迭代的区别
- 循环是一种控制流结构，它反复执行一组语句。
2.迭代是对序列中的元素进行逐个访问的过程，通常使用迭代器实现。
3.循环可以是有限的（通过设置退出条件）或无限的（使用loop关键字)。
4.迭代器提供了一种更抽象的方式来处理序列，使得代码更具可读性和灵活性。
在Rust中，循环和迭代性能的差距可能会取决于具体的使用情况和编译器的优化。绝大多数情况下，Rust的迭代器是经过优化的，可以达到或接近手动编写循环的性能水平。
fn sum_with_loop(arr: &[i32]) -> i32 {
let mut sum = 0;
for &item in arr {
sum += item;
}
sum
}
fn sum_with_iter(arr: &[i32]) -> i32 {
arr.iter().sum()
}
fn main() {
const ARRAY_SIZE: usize = 1_000;
let array:Vec<i32> = (1..=ARRAY_SIZE as i32).collect();
let sum1 = sum_with_loop(&array);
let sum2 = sum_with_iter(&array);
println!("sum loop {}", sum1);
println!("sum iter {}", sum2);
}
IntoIterator、Iterator和Iter之间的关系
IntoIterator Trait
Intol terator是一个Rust Trait,它定义了一种将类型转换为迭代器的能力。
该Trait包含一个方法into_iter,该方法返回一个实现了lterator Trait的迭
代器。
通常，当你有一个类型，希望能够对其进行迭代时，你会实现Intolterator Trait
来提供将该类型转换为迭代器的方法。
Iterator Trait
-
lterator是Rust标准库中的Trait,定义了一种访问序列元素的方式。
-
它包含了一系列方法，如
next、map、filter、sum等，用于对序列进行不同类型的操作。 -
通过实现
lteratorTrait，你可以创建自定义的迭代器，以定义如何迭代你的类型中的元素。
pub trait Iterator {
type Item;
fn next (&mut self) -> Option<Self::Item>;
}
源码中经常出现的Iter
-
Iter是lterator Trait的一个具体实现，通常用于对集合中的元素进行迭代。
-
在Rust中，你会经常看到Iter，特别是在对数组、切片等集合类型进行迭代时。
-
通过Intolterator Trait，你可以获取到一个特定类型的迭代器，比如Iter，然后可以使用Iterator Trait的方法进行操作。
fn main(){
let array = [1,2,3,4,5];
let iter = array.iter();
let sum: i32 = iter.sum();
println!("{sum}");
let text = "hello world";
let iter = text.chars();
let uppercase: String = iter.map(|c| c.to_ascii_uppercase()).collect::<String>();
println!("{}", uppercase);
println!("{:?}", text);
}
获取迭代器的三种方法
iter()
iter()方法返回一个不可变引用的迭代器，用于只读访问集合的元素
该方法适用于你希望在不修改集合的情况下迭代元素的场景。
iter_mut()
iter_mut() 方法返回一个可变引用的迭代器，用于允许修改集合中的元素。
该方法适用于你希望在迭代过程中修改集合元素的场景。
into_iter()
into_iter()方法返回一个拥有所有权的迭代器，该迭代器会消耗集合本身，将所有权转移到迭代器。
该方法适用于你希望在迭代过程中拥有集合的所有权，以便进行消耗性的操作，如移除元素。
自定义类型实现iter、iter_mut、into_iter()
#[derive(Debug)]
struct Stack<T> {
items: Vec<T>,
}
impl<T> Stack<T> {
fn new() -> Self {
Stack{items: Vec::new()}
}
// 入栈
fn push(&mut self, item: T) {
self.items.push(item);
}
// 出栈
fn pop(&mut self) -> Option<T> {
self.items.pop()
}
// 不可变引用
fn iter(&self) -> std::slice::Iter<T> {
self.items.iter()
}
fn iter_mut(&mut self) -> std::slice::IterMut<T> {
self.items.iter_mut()
}
fn into_iter(self) -> std::vec::IntoIter<T> {
self.items.into_iter()
}
}
fn main() {
let mut my_stack = Stack::new();
my_stack.push(1);
my_stack.push(2);
my_stack.push(3);
for item in my_stack.iter() {
println!("Item: {item}");
}
println!("{:?}", my_stack);
for item in my_stack.iter_mut() {
*item *= 2;
}
println!("{:?}", my_stack);
for item in my_stack.into_iter() {
println!("{}", item);
}
}