Java迭代器深拷贝：不消耗原迭代器或重置索引的实现问询

这个问题问到点子上了——Java标准库的Iterator本身确实不支持直接复制或者重置，因为它设计成单向、一次性的遍历工具，遍历过程中会和底层集合的当前位置绑定，一旦前进就没法回头。不过我们有几种办法能实现你想要的效果，分情况来看：

如果你的迭代器是从某个集合（比如List、Set）获取的，那最直接的方式就是直接从原集合生成一个新的迭代器，两个迭代器完全独立，互不影响：

// 假设原迭代器iter1是从list获取的
List<String> list = new ArrayList<>();
// 先填充list...
Iterator<String> iter1 = list.iterator();
// 直接从原集合复制出iter2
Iterator<String> iter2 = list.iterator();

// 现在两个迭代器都能正常遍历，互不干扰
while(iter1.hasNext()) {
    System.out.println(iter1.next()); // 正常输出，不受iter2影响
}

while(iter2.hasNext()) {
    System.out.println(iter2.next()); // 也能正常输出
}

这是最推荐的方案，因为不需要额外的内存开销，逻辑也最简单。

如果你的迭代器是别人传递给你的，没法拿到底层集合，那可以先把迭代器的所有元素缓存到一个临时集合（比如ArrayList）里，之后就可以从这个缓存集合生成任意多个迭代器：

// 假设你只能拿到iter1，不知道它来自哪个集合
Iterator<String> iter1 = ...;

// 先缓存所有元素
List<String> elementCache = new ArrayList<>();
while(iter1.hasNext()) {
    elementCache.add(iter1.next());
}

// 现在可以生成任意多个独立的迭代器
Iterator<String> iter1Copy = elementCache.iterator();
Iterator<String> iter2 = elementCache.iterator();

// 缓存后的集合可以反复遍历，完全满足需求
while(iter1Copy.hasNext()) {
    System.out.println(iter1Copy.next());
}

注意：这个方法会消耗原迭代器（iter1遍历完就不能用了），但缓存后的集合可以无限生成新迭代器，相当于把一次性的迭代器变成了可复用的集合。

如果你的场景需要频繁重置或复制迭代器，可以自己实现一个包装类，封装底层集合并提供重置、复制功能：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

public class ResettableIterator<T> implements Iterator<T> {
    private final List<T> sourceList;
    private int currentIndex = 0;

    // 构造方法：传入底层集合，内部做复制避免外部修改影响
    public ResettableIterator(List<T> source) {
        this.sourceList = new ArrayList<>(source);
    }

    @Override
    public boolean hasNext() {
        return currentIndex < sourceList.size();
    }

    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException("No more elements");
        }
        return sourceList.get(currentIndex++);
    }

    // 重置迭代器到起始位置
    public void reset() {
        currentIndex = 0;
    }

    // 复制当前迭代器（可选择复制当前位置或重置到开头）
    public ResettableIterator<T> copy() {
        ResettableIterator<T> copy = new ResettableIterator<>(sourceList);
        copy.currentIndex = this.currentIndex; // 复制当前遍历位置
        // 若想让复制的迭代器从开头开始，替换为 copy.reset();
        return copy;
    }
}

使用示例：

List<String> data = List.of("a", "b", "c");
ResettableIterator<String> iter1 = new ResettableIterator<>(data);

// 复制迭代器
ResettableIterator<String> iter2 = iter1.copy();

// 遍历iter1到第二个元素
iter1.next(); // 输出a
iter1.next(); // 输出b

// 重置iter1到开头，重新遍历
iter1.reset();
while(iter1.hasNext()) {
    System.out.println(iter1.next()); // 重新输出a、b、c
}

// iter2不受iter1操作影响，正常遍历
while(iter2.hasNext()) {
    System.out.println(iter2.next()); // 输出a、b、c
}

这个方案完全自定义了迭代器的行为，能完美满足你“复制后原迭代器仍可使用”“重置迭代器”的需求。

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