如何判断过滤迭代器（filtered iterator）是否为空且保留其迭代器特性？

这个问题确实挺棘手的——毕竟过滤迭代器大多是惰性求值的，而且很多语言里它确实没法直接克隆，毕竟迭代器本身是带状态的，走一遍就消耗掉了。不过咱们有几个可行的方案，既能判断它是不是空，还能把迭代器原封不动留着后续用：

方案一：提前“偷看”首元素，再重组迭代器 #

核心思路是：先尝试取出迭代器的第一个元素——如果拿不到，说明迭代器是空的；如果拿到了，就把这个元素和剩下的迭代器重新链起来，这样后续使用时和原迭代器的效果完全一致。

举几个不同语言的例子：

Rust 实现 #

use std::iter::{self, Filter};

fn check_filter_empty<I, F>(mut iter: Filter<I, F>) -> (bool, impl Iterator<Item = I::Item>)
where
    I: Iterator,
    F: FnMut(&I::Item) -> bool,
{
    let first_element = iter.next();
    let is_empty = first_element.is_none();
    // 将取出的首元素和剩余迭代器重新组合
    let restored_iter = iter::once(first_element).flatten().chain(iter);
    (is_empty, restored_iter)
}

Python 实现 #

from itertools import chain

def check_filter_empty(filter_iter):
    try:
        # 尝试取出第一个元素
        first_element = next(filter_iter)
    except StopIteration:
        # 抛出异常说明迭代器为空
        return (True, filter_iter)
    # 把首元素放回，重组迭代器
    restored_iter = chain([first_element], filter_iter)
    return (False, restored_iter)

方案二：转换为可重复访问的集合（内存允许时使用） #

如果你的迭代器元素数量不多、内存压力不大，最简单的方法就是把过滤迭代器的所有元素一次性收集到一个集合里（比如数组、列表）。这样不仅能直接判断集合是否为空，还能随时重新生成迭代器供后续使用。

Rust 实现 #

// 先收集过滤后的所有元素到Vec中
let filtered_elements: Vec<_> = original_iter.filter(|x| x > &5).collect();
let is_empty = filtered_elements.is_empty();
// 后续使用时，重新生成迭代器即可
let reuse_iter = filtered_elements.into_iter();

Python 实现 #

# 转换为列表
filtered_list = list(filter_iter)
is_empty = len(filtered_list) == 0
# 后续使用时重新生成迭代器
reuse_iter = iter(filtered_list)

这个方法的优点是简单直观，缺点是如果元素数量极大，会占用大量内存，不适合大数据场景。

方案三：自定义包装迭代器，记录空状态 #

如果上面的方案都不符合你的需求，你可以自己写一个迭代器包装器，把过滤迭代器包起来，在第一次判断空的时候偷偷记录状态，同时不影响后续迭代。

以 Rust 为例：

struct PeekableFilter<I, F> {
    inner_filter: Filter<I, F>,
    peeked_item: Option<I::Item>,
    is_empty_status: Option<bool>,
}

impl<I, F> PeekableFilter<I, F>
where
    I: Iterator,
    F: FnMut(&I::Item) -> bool,
{
    // 创建包装后的迭代器
    fn new(inner: Filter<I, F>) -> Self {
        Self {
            inner_filter: inner,
            peeked_item: None,
            is_empty_status: None,
        }
    }

    // 判断是否为空
    fn is_empty(&mut self) -> bool {
        // 如果已经判断过状态，直接返回
        if let Some(status) = self.is_empty_status {
            return status;
        }
        // 尝试取出第一个元素，记录状态
        self.peeked_item = self.inner_filter.next();
        self.is_empty_status = Some(self.peeked_item.is_none());
        self.is_empty_status.unwrap()
    }
}

// 实现 Iterator trait，保证正常迭代逻辑
impl<I, F> Iterator for PeekableFilter<I, F>
where
    I: Iterator,
    F: FnMut(&I::Item) -> bool,
{
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        // 先返回之前偷看的元素
        if let Some(item) = self.peeked_item.take() {
            return Some(item);
        }
        // 再从内部过滤迭代器取元素
        self.inner_filter.next()
    }
}

使用时，你只需要把原过滤迭代器传入PeekableFilter::new()，先调用is_empty()判断状态，之后正常迭代包装后的迭代器即可。

内容的提问来源于stack exchange，提问作者SquattingSlavInTracksuit