2024 Rust现代实用教程Iterator迭代器
文章目录
一、迭代与循环
1.循环
定义：循环是一种控制流结构，它会反复执行一组语句，直到满足某个条件。
控制条件：循环通常包含一个条件表达式，只有在条件为真时，循环体中的语句才会执行。
退出条件：循环执行直到条件不再满足，或者通过break、语句显式中断循环。
使用场景：适用于需要反复执行某个操作直到满足某个条件的情况。
2.迭代iteration
·定义：选代是对序列中的元素进行逐个访问的过程。
·控制条件：迭代通常使用迭代器（lterator）来实现，迭代器提供了对序列元素的访问和操作。
·退出条件：通常不需要显式的退出条件，迭代器会在处理完所有元素后自动停止。
·使用场景：适用于需要遍历数据结构中的元素的情况，例如数组、切片、集合等。
3.区别
·1.循环是一种控制流结构，它反复执行一组语句。
·2.送代是对序列中的元素进行逐个访问的过程，通常使用迭代器实现。
·3.循环可以是有限的（通过设置退出条件）或无限的（使用loop）关键字）。
·4.迭代器提供了一种更抽象的方式来处理序列，使得代码更具可读性和灵活性。
在Rust中，循环和迭代性能的差距可能会取决于具体的使用情况和编译器的优化。绝大多数情况下，Rust的迭代器是经过优化的，可以达到或接近手动编写循环的性能水平。
// &[i32] &Vec
// loop
fn sum_with_loop(arr: &[i32]) -> i32 {
let mut sum = 0;
for &item in arr {
sum += item;
}
sum
}
// iter
fn sum_with_iter(arr: &[i32]) -> i32 {
arr.iter().sum()
}
fn main() {
const ARRAY_SIZE: usize = 10000;
let array: Vec<i32> = (1..=ARRAY_SIZE as i32).collect();
let sum1 = sum_with_loop(&array);
println!("sum loop {}", sum1);
let sum2 = sum_with_iter(&array);
println!("sum loop {}", sum2);
}
编译及运行：
▶ cargo run
Compiling ch5_iter_loop v0.1.0 (/home/wangji/code/rust/2024_rust/rust_project/ch4_iter_loop)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 19.20s
Running `target/debug/ch5_iter_loop`
sum loop 50005000
sum loop 50005000
二、Intoiterator、Iterator和Iter之间的关系
1.Intolterator
Intolterator是一个RustTrait，它定义了一种将类型转换为迭代器的能力。
该Trait包含一个方法into_iter，该方法返回一个实现了IteratorTrait的迭代器。
通常，当你有一个类型，希望能够对其进行迭代时，你会实现IntolteratorTrait来提供将该类型转换为迭代器的方法。
2.Iterator Trait
Iterator是Rust标准库中的Trait，定义了一种访问序列元素的方式。
·它包含了一系列方法，如next、map、filter、sum、等，用于对序列进行不同类型的操作。
·通过实现Iterator丶Trait，你可以创建自定义的迭代器，以定义如何迭代你的类型中的元素。
pub trait Iterator{
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
3. 源码中经常出现的iter
·Iter是IteratorTrait的一个具体实现，通常用于对集合中的元素进行迭代。
·在Rust中，你会经常看到Iter，特别是在对数组、切片等集合类型进行迭代时。
·通过lntolteratorTrait，你可以获取到一个特定类型的迭代器，比如Iter，然后可以使用IteratorTrait的方法进行操作。
fn main() {
// vec
let v = vec![1, 2, 3, 4, 5]; // intoIterator 特质 into_iter
// 转换为迭代器
let iter = v.into_iter(); // move 所有权转移 类似ppt中的Iter Iterator的特质对象
let sum: i32 = iter.sum();
println!("sum: {}", sum);
// println!("{:?}", v)
// array
let array = [1, 2, 3, 4, 5];
let iter: std::slice::Iter<'_, i32> = array.iter();//所有权没有转移
let sum: i32 = iter.sum();
println!("sum: {}", sum);
println!("{:?}", array);
// chars
let text = "hello, world!";
let iter = text.chars();//所有权没有转移
// 等价于let uppercase：String = iter.map(|c| c.to_ascii_uppercase()).collect();
// collect表示迭代器的下一个， <String>表示返回的类型是String
let uppercase = iter.map(|c| c.to_ascii_uppercase()).collect::<String>();
println!("uppercase: {}", uppercase);
println!("{:?}", text);
}
编译及运行
▶ cargo run
Compiling ch2_intoiterator_iterator_iter v0.1.0 (/home/wangji/code/rust/2024_rust/rust_project/ch5_intoiterator_iterator_iter)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 11.04s
Running `target/debug/ch2_intoiterator_iterator_iter`
sum: 15
sum: 15
[1, 2, 3, 4, 5]
uppercase: HELLO, WORLD!
"hello, world!"
三、获取迭代器的三种方法iter(),iter_mut()和into_iter()
1.iter()方法
iter（）方法返回一个不可变引用的迭代器，用于只读访问集合的元素。
该方法适用于你希望在不修改集合的情况下迭代元素的场景。
2.iter_mut()方法
iter_mut（）方法返回一个可变引用的迭代器，用于允许修改集合中的元素。
该方法适用于你希望在迭代过程中修改集合元素的场景。
3.into_iter()方法—尽量写
into_iter（）方法返回一个拥有所有权的迭代器，该迭代器会消耗集合本身，将所有权转移到迭代器。
该方法适用于你希望在迭代过程中拥有集合的所有权，以便进行消耗性的操作，如移除元素。
fn main() {
let vec = vec![1, 2, 3, 4, 5];
// iter（）
for &item in vec.iter() {
println!("{}", item);
}
println!("{:?}", vec);
// 可变引用
let mut vec = vec![1, 2, 3, 4, 5];
for item in vec.iter_mut() {
*item *= 2;
}
// 所有权转移
println!("{:?}", vec);
let vec = vec![1, 2, 3, 4, 5];
for item in vec.into_iter() {
println!("{}", item);
}
// println!("{:?}", vec);
}
编译加运行
▶ cargo run
Compiling ch3_iter v0.1.0 (/home/wangji/code/rust/2024_rust/rust_project/ch6_iter)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 10.14s
Running `target/debug/ch3_iter`
1
2
3
4
5
[1, 2, 3, 4, 5]
[2, 4, 6, 8, 10]
1
2
3
4
5
四、自定义类型实现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);
}
// println!("{:?}", my_stack);
}
编译及运行
cargo run
Compiling ch28_custom_iter v0.1.0 (/home/wangji/installer/rust/project/ch28_custom_iter)
warning: method `pop` is never used
--> src/main.rs:15:8
|
6 | impl<T> Stack<T> {
| ---------------- method in this implementation
...
15 | fn pop(&mut self) -> Option<T> {
| ^^^
|
= note: `#[warn(dead_code)]` on by default
warning: `ch28_custom_iter` (bin "ch28_custom_iter") generated 1 warning
Finished `dev` profile [unoptimized + debuginfo] target(s) in 12.50s
Running `target/debug/ch28_custom_iter`
Item 1
Item 2
Item 3
Stack { items: [1, 2, 3] }
Stack { items: [2, 4, 6] }
2
4
6
参考
原文地址：https://blog.csdn.net/u011436427/article/details/143464297
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！