Rust自定义迭代器
Rust要自定迭代器要实现Iterator这个Trait，就可以使用next方法，也可以实现IntoIterator方法就可以把对象转换为一个迭代器。这与Python中的可迭代对象和迭代器的概念类似。在Python中，实现了__iter__方法就是一个可迭代对象，再实现__next__方法就是一个迭代器。
Python的迭代器和可迭代对象
Iterator定义
pub trait Iterator{type Item;fn next(&mut self) -> Option<Self::Item>;
}
实现了Iterator的对象就是一个迭代器类型
IntoIterator
实现了IntoIterator就可以使用for in循环了
pub trait IntoIterator {type Item;type IntoIter: Iterator<Item=Self::Item>;fn into_iter(self) -> Self::IntoIter;
}// 实现了Iterator可以自动实现IntoIterator
impl<I: Iterator> IntoIterator for I {type Item = I::Item;type IntoIter = I;#[inline]fn into_iter(self) -> I {self}
}
示例
struct Node<T> {value: T,next: Option<Box<Node<T>>>
}struct LinkedList<T> {head: Option<Box<Node<T>>>,length: usize
}impl <T> Node<T> {fn new(value: T) -> Self {Node { value, next: None }}
}impl <T> LinkedList<T> {fn new() -> Self {LinkedList { head: None, length: 0 }}fn push_front(&mut self, value: T) {let new_node = Box::new(Node{value, next: self.head.take()});self.head = Some(new_node);self.length += 1;}fn pop_front(&mut self) -> Option<T> {self.head.take().map(|node| {self.head = node.next;self.length -= 1;node.value})}fn peek(&self) -> Option<&T> {self.head.as_ref().map(|node| {&node.value})}fn len(&self) -> &usize {&self.length}fn is_empty(&self) -> bool {*self.len() == 0}fn contains(&self, value: T) -> bool where T: PartialEq{let mut current = &self.head;while let Some(node) = current {if node.value == value {return true;}current = &node.next;}false}fn reverse(&mut self) {let mut prev = None;let mut current = self.head.take();while let Some(mut node) = current {let next = node.next.take();node.next = prev;prev = Some(node);current = next;}self.head = prev;}fn clear(&mut self) {self.length = 0;self.head = None;}fn reverse_recursive(&mut self) {fn recusive<T> (head: Option<Box<Node<T>>>, pre: Option<Box<Node<T>>>) -> Option<Box<Node<T>>> {if head.is_none() {return pre;}let mut cur = head.unwrap();let next: Option<Box<Node<T>>> = cur.next.take();cur.next = pre;recusive(next, Some(cur))}self.head = recusive(self.head.take(), None);}fn reverse_recursive2(&mut self) {fn recusive<T> (head: Option<Box<Node<T>>>, pre: Option<Box<Node<T>>>) -> Option<Box<Node<T>>> {match head {Some(mut node) => {let next = node.next.take();node.next = pre;recusive(next, Some(node))},None => pre}}}}struct IntoIter<T> {list: LinkedList<T>
}struct Iter<'a, T> {next: Option<&'a Node<T>>
}struct IterMut<'a, T> {next: Option<&'a mut Node<T>>
}impl<T> Iterator for IntoIter<T> {type Item = T;fn next(&mut self) -> Option<Self::Item> {self.list.pop_front()}}impl<T> IntoIterator for LinkedList<T> {type Item = T;type IntoIter = IntoIter<T>;fn into_iter(self) -> Self::IntoIter {IntoIter {list: self}}}impl <'a, T> Iterator for Iter<'a, T> {type Item = &'a T;fn next(&mut self) -> Option<Self::Item> {self.next.map(|node| {self.next = node.next.as_deref();&node.value})}
}impl<T> LinkedList<T> {pub fn iter(&self) -> Iter<'_, T> {Iter { next: self.head.as_deref() }}
}impl<'a, T> Iterator for IterMut<'a, T> {type Item = &'a mut T;fn next(&mut self) -> Option<Self::Item> {self.next.take().map(|node| {self.next = node.next.as_deref_mut();&mut node.value})}
}impl<T> LinkedList<T> {pub fn iter_mut(&mut self) ->IterMut<'_, T> {IterMut { next: self.head.as_deref_mut() }}
}fn main() {let mut list = LinkedList::new();list.push_front(1);list.push_front(2);list.push_front(3);assert_eq!(list.pop_front(), Some(3));assert_eq!(list.pop_front(), Some(2));assert_eq!(list.pop_front(), Some(1));assert_eq!(list.pop_front(), None);}