1. 迭代器模式：为什么我们需要它？

记得刚入行那会儿，我接手了一个电商平台的商品管理系统。当时直接用了ArrayList存储商品数据，结果在实现商品列表遍历时，代码里到处都是for循环和get(index)操作。后来需求变更要改用HashSet存储，所有遍历逻辑都得重写——这就是我初次遭遇"遍历灾难"的经历。

迭代器模式(Iterator Pattern)正是为解决这类问题而生。它提供了一种统一的方法来顺序访问聚合对象中的各个元素，而又不暴露其底层表示。简单说，就是不管你的数据存在ArrayList、LinkedList还是自定义容器里，我都能用同样的方式遍历它们。

关键理解：迭代器模式的核心价值在于将遍历行为从聚合对象中分离出来，实现"单一职责原则"。

2. 模式结构与实现原理

2.1 UML类图解析

典型的迭代器模式包含以下核心角色：

1. Iterator（迭代器接口）

   • hasNext(): 判断是否还有下一个元素
   • next(): 获取下一个元素
   • (可选)remove(): 删除当前元素

2. ConcreteIterator（具体迭代器）

   • 实现迭代器接口
   • 维护遍历过程中的当前位置

3. Aggregate（聚合接口）

   • createIterator(): 创建对应的迭代器

4. ConcreteAggregate（具体聚合）

   • 实现创建迭代器的方法
   • 持有实际的数据集合

// 迭代器接口示例 public interface Iterator<T> { boolean hasNext(); T next(); default void remove() { throw new UnsupportedOperationException(); } }

2.2 Java集合框架中的实现

Java的Collection框架是迭代器模式的经典应用。以ArrayList为例：

List<String> list = new ArrayList<>(); // 获取迭代器 Iterator<String> it = list.iterator(); while(it.hasNext()) { String item = it.next(); System.out.println(item); }

有趣的是，Java的迭代器实现还有个"快速失败"(fail-fast)机制——当迭代过程中集合被修改，会立即抛出ConcurrentModificationException。这个设计体现了迭代器模式的另一个优势：可以在遍历时控制集合的修改行为。

3. 深度实现与优化技巧

3.1 线程安全版本实现

标准迭代器不是线程安全的。下面是一个线程安全的迭代器实现方案：

public class SafeIterator<T> implements Iterator<T> { private final List<T> snapshot; private int cursor; public SafeIterator(Collection<T> collection) { this.snapshot = new ArrayList<>(collection); // 创建快照 this.cursor = 0; } @Override public boolean hasNext() { return cursor < snapshot.size(); } @Override public T next() { if (!hasNext()) throw new NoSuchElementException(); return snapshot.get(cursor++); } }

这种"快照"式迭代器虽然消耗更多内存，但完全避免了并发修改问题，适合读多写少的场景。

3.2 懒加载迭代器

对于大型数据集，可以设计懒加载迭代器：

public class LazyIterator implements Iterator<Data> { private int currentPage = 0; private int currentIndex = 0; private List<Data> currentBatch; @Override public boolean hasNext() { if (currentBatch == null || currentIndex >= currentBatch.size()) { currentBatch = loadNextBatch(currentPage++); currentIndex = 0; } return currentBatch != null && !currentBatch.isEmpty(); } private List<Data> loadNextBatch(int page) { // 实现分页加载逻辑 } }

4. 实战应用场景分析

4.1 树形结构遍历

迭代器模式特别适合处理复杂数据结构。比如二叉树的迭代器实现：

public class BSTIterator { private Stack<TreeNode> stack = new Stack<>(); public BSTIterator(TreeNode root) { pushAllLeft(root); } private void pushAllLeft(TreeNode node) { while (node != null) { stack.push(node); node = node.left; } } public boolean hasNext() { return !stack.isEmpty(); } public int next() { TreeNode node = stack.pop(); pushAllLeft(node.right); return node.val; } }

这种实现以O(h)的内存空间实现了中序遍历，h是树的高度。

4.2 多集合联合迭代

需要遍历多个集合时，迭代器模式能优雅地解决问题：

public class CompositeIterator<T> implements Iterator<T> { private Iterator<Iterator<T>> metaIterator; private Iterator<T> current; public CompositeIterator(Collection<Collection<T>> collections) { List<Iterator<T>> iterators = new ArrayList<>(); for (Collection<T> c : collections) { iterators.add(c.iterator()); } metaIterator = iterators.iterator(); } @Override public boolean hasNext() { while ((current == null || !current.hasNext()) && metaIterator.hasNext()) { current = metaIterator.next(); } return current != null && current.hasNext(); } }

5. 性能考量与最佳实践

5.1 迭代器 vs for循环

对于ArrayList这样的随机访问集合，传统for循环确实比迭代器稍快（约10-15%），因为：

• 避免了方法调用的开销
• 直接使用索引访问元素

但在LinkedList等顺序访问集合中，迭代器性能明显更优，因为：

• for循环的get(index)是O(n)操作
• 迭代器内部维护了当前位置，是O(1)操作

经验法则：除非确定集合类型且需要极致性能，否则优先使用迭代器。

5.2 内存优化技巧

1. 重用迭代器对象：

   // 不推荐 for (Item item : collection) { ... } // 推荐（减少对象创建） Iterator<Item> it = collection.iterator(); while (it.hasNext()) { ... }

2. 避免装箱拆箱： 对于原始类型集合，考虑使用专门迭代器：

   IntIterator it = intCollection.intIterator(); while (it.hasNext()) { int value = it.next(); // 无装箱开销 }

6. 现代Java中的演进

6.1 Stream API的底层实现

Java 8的Stream API大量使用了迭代器模式。比如这段代码：

list.stream() .filter(s -> s.length() > 3) .map(String::toUpperCase) .forEach(System.out::println);

实际上，每个中间操作都会创建一个新的迭代器实现类。filter操作对应的迭代器会跳过不满足条件的元素，map操作对应的迭代器会在next()时应用转换函数。

6.2 并行迭代的实现

并行流(parallelStream)使用了更复杂的ForkJoinPool和Spliterator机制，但核心思想仍是迭代器模式的扩展：

public interface Spliterator<T> { boolean tryAdvance(Consumer<? super T> action); Spliterator<T> trySplit(); }

Spliterator的trySplit方法允许将迭代任务分解为多个子任务，这是实现并行遍历的关键。

7. 常见陷阱与解决方案

7.1 并发修改异常

最常见的错误是在迭代过程中修改集合：

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c")); for (String s : list) { if (s.equals("b")) { list.remove(s); // 抛出ConcurrentModificationException } }

解决方案：

1. 使用迭代器的remove方法
2. 使用CopyOnWriteArrayList等线程安全集合
3. 先收集要删除的元素，最后统一删除

7.2 内存泄漏风险

自定义迭代器如果持有集合引用，可能导致内存泄漏：

public class LeakyIterator implements Iterator<Item> { private BigCollection collection; // 强引用 private int index; // ... }

解决方法：

1. 使用弱引用(WeakReference)
2. 及时清除迭代器引用
3. 采用快照模式

8. 设计模式组合应用

8.1 与组合模式结合

处理树形结构时，组合模式+迭代器模式是黄金搭档：

interface Component { Iterator<Component> createIterator(); } class Leaf implements Component { public Iterator<Component> createIterator() { return Collections.emptyIterator(); } } class Composite implements Component { private List<Component> children = new ArrayList<>(); public Iterator<Component> createIterator() { return new CompositeIterator(children); } }

8.2 与访问者模式结合

需要遍历复杂结构并执行操作时：

public class VisitorIterator { public void traverse(Element root, Visitor visitor) { Iterator<Element> it = root.createIterator(); while (it.hasNext()) { Element e = it.next(); e.accept(visitor); } } }

这种组合既保持了元素的遍历方式可扩展，又使操作逻辑与结构分离。

9. 其他语言的实现差异

9.1 C++的实现方式

C++通过运算符重载实现迭代器：

for (auto it = vec.begin(); it != vec.end(); ++it) { std::cout << *it << std::endl; }

与Java不同，C++迭代器通常直接操作指针，性能更高但风险也更大。

9.2 Python的迭代协议

Python使用__iter__和__next__方法实现迭代协议：

class CountDown: def __init__(self, start): self.current = start def __iter__(self): return self def __next__(self): if self.current <= 0: raise StopIteration num = self.current self.current -= 1 return num

Python生成器(yield)本质上也是迭代器模式的语法糖。

10. 测试迭代器实现

10.1 单元测试策略

测试迭代器时需要覆盖的特殊情况：

• 空集合的迭代
• 连续调用next()超过元素数量
• 混合调用hasNext()和next()
• 并发修改场景

示例测试用例：

@Test public void testEmptyCollection() { Iterator<String> it = Collections.emptyList().iterator(); assertFalse(it.hasNext()); assertThrows(NoSuchElementException.class, it::next); } @Test public void testConcurrentModification() { List<String> list = new ArrayList<>(Arrays.asList("a", "b")); Iterator<String> it = list.iterator(); list.add("c"); assertThrows(ConcurrentModificationException.class, it::next); }

10.2 性能测试要点

需要关注的性能指标：

• 迭代器创建开销
• 单次next()调用耗时
• 内存占用情况
• 多线程竞争下的吞吐量

可以使用JMH进行基准测试：

@Benchmark @BenchmarkMode(Mode.AverageTime) public void testIteration(Blackhole bh) { for (String s : testData) { bh.consume(s); } }

11. 实际项目经验分享

在开发一个金融数据分析系统时，我们遇到了需要处理超大型时间序列数据的挑战。原始实现是先把所有数据加载到内存，再用迭代器处理，经常导致OOM。后来我们实现了基于内存映射文件的迭代器：

public class MappedFileIterator implements Iterator<DataRecord> { private MappedByteBuffer buffer; private int recordSize; public DataRecord next() { byte[] record = new byte[recordSize]; buffer.get(record); return parseRecord(record); } }

这种实现允许我们处理远大于内存的数据集，迭代速度仍保持在可接受范围内。关键经验是：迭代器模式不仅关乎接口统一，更是控制资源消耗的有力工具。

另一个教训来自缓存系统的开发。我们最初为每个查询创建新迭代器，后来发现当频繁遍历相同数据时，这会造成大量重复计算。解决方案是实现缓存迭代器：

public class CachedIterator<T> implements Iterator<T> { private final Iterator<T> source; private final List<T> cache = new ArrayList<>(); private int index = 0; public T next() { if (index < cache.size()) { return cache.get(index++); } T item = source.next(); cache.add(item); index++; return item; } }

这样重复遍历时可以直接从缓存读取，大幅提升了热点数据的访问速度。