迭代器模式：统一不同数据结构的遍历方式

迭代器模式：统一不同数据结构的遍历方式

一、模式核心：分离数据遍历与数据表示

在开发中，我们经常需要遍历不同的数据结构，如数组、链表、树等。若在客户端代码中直接编写遍历逻辑，不仅会导致代码冗余，而且当数据结构发生变化时，遍历逻辑也需要随之修改。迭代器模式（Iterator Pattern 通过将遍历逻辑封装成独立的迭代器对象，实现数据结构与遍历算法的解耦，核心解决：

• 统一遍历接口：为不同数据结构提供一致的遍历方式，如hasNext()、next()。
• 隐藏数据结构细节：客户端无需了解数据存储的具体结构（如链表的节点操作），仅通过迭代器操作数据。
• 支持复杂遍历：方便实现倒序遍历、跳跃遍历等特殊遍历需求。

核心思想与 UML 类图

迭代器模式主要包含迭代器接口、具体迭代器、聚合接口和具体聚合四个角色：

二、核心实现：自定义数组与链表的统一遍历

1. 定义迭代器接口（规范遍历操作）

public interface Iterator {boolean hasNext();Object next();
}

2. 定义聚合接口（提供创建迭代器的方法）

public interface Aggregate {Iterator createIterator();
}

3. 实现具体聚合类（以数组为例）

public class ArrayAggregate implements Aggregate {private Object[] items;private int size;public ArrayAggregate(int capacity) {items = new Object[capacity];}public void addItem(Object item) {items[size++] = item;}public int size() {return size;}public Object getItem(int index) {return items[index];}@Overridepublic Iterator createIterator() {return new ArrayIterator(this);}// 具体迭代器类（内部类）private class ArrayIterator implements Iterator {private ArrayAggregate aggregate;private int index = 0;public ArrayIterator(ArrayAggregate aggregate) {this.aggregate = aggregate;}@Overridepublic boolean hasNext() {return index < aggregate.size();}@Overridepublic Object next() {return aggregate.getItem(index++);}}
}

4. 实现链表聚合类及对应迭代器

// 链表节点类
class ListNode {Object data;ListNode next;public ListNode(Object data) {this.data = data;}
}// 链表聚合类
public class ListAggregate implements Aggregate {private ListNode head;public void addItem(Object item) {ListNode newNode = new ListNode(item);if (head == null) {head = newNode;} else {ListNode current = head;while (current.next != null) {current = current.next;}current.next = newNode;}}@Overridepublic Iterator createIterator() {return new ListIterator(head);}// 链表迭代器类private class ListIterator implements Iterator {private ListNode current;public ListIterator(ListNode head) {this.current = head;}@Overridepublic boolean hasNext() {return current != null;}@Overridepublic Object next() {Object data = current.data;current = current.next;return data;}}
}

5. 客户端调用示例

public class ClientDemo {public static void main(String[] args) {// 使用数组聚合类ArrayAggregate arrayAggregate = new ArrayAggregate(3);arrayAggregate.addItem("Apple");arrayAggregate.addItem("Banana");arrayAggregate.addItem("Cherry");Iterator arrayIterator = arrayAggregate.createIterator();while (arrayIterator.hasNext()) {System.out.println(arrayIterator.next());}// 使用链表聚合类ListAggregate listAggregate = new ListAggregate();listAggregate.addItem("Dog");listAggregate.addItem("Elephant");listAggregate.addItem("Fox");Iterator listIterator = listAggregate.createIterator();while (listIterator.hasNext()) {System.out.println(listIterator.next());}}
}

三、进阶：实现倒序遍历与并发安全迭代器

1. 倒序遍历迭代器

public class ReverseArrayIterator implements Iterator {private ArrayAggregate aggregate;private int index;public ReverseArrayIterator(ArrayAggregate aggregate) {this.aggregate = aggregate;this.index = aggregate.size() - 1;}@Overridepublic boolean hasNext() {return index >= 0;}@Overridepublic Object next() {return aggregate.getItem(index--);}
}// 客户端调用倒序遍历
ArrayAggregate arrayAggregate = new ArrayAggregate(3);
// 添加元素...
Iterator reverseIterator = new ReverseArrayIterator(arrayAggregate);
while (reverseIterator.hasNext()) {System.out.println(reverseIterator.next());
}

2. 并发安全迭代器（使用读写锁）

import java.util.concurrent.locks.ReentrantReadWriteLock;public class ThreadSafeArrayAggregate implements Aggregate {private Object[] items;private int size;private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();public ThreadSafeArrayAggregate(int capacity) {items = new Object[capacity];}public void addItem(Object item) {lock.writeLock().lock();try {items[size++] = item;} finally {lock.writeLock().unlock();}}public int size() {lock.readLock().lock();try {return size;} finally {lock.readLock().unlock();}}public Object getItem(int index) {lock.readLock().lock();try {return items[index];} finally {lock.readLock().unlock();}}@Overridepublic Iterator createIterator() {return new ThreadSafeArrayIterator(this);}private class ThreadSafeArrayIterator implements Iterator {private ThreadSafeArrayAggregate aggregate;private int index = 0;public ThreadSafeArrayIterator(ThreadSafeArrayAggregate aggregate) {this.aggregate = aggregate;}@Overridepublic boolean hasNext() {lock.readLock().lock();try {return index < aggregate.size();} finally {lock.readLock().unlock();}}@Overridepublic Object next() {lock.readLock().lock();try {return aggregate.getItem(index++);} finally {lock.readLock().unlock();}}}
}

四、框架与源码中的迭代器实践

1. Java 集合框架（java.util包）

• 核心接口：java.util.Iterator 和 java.util.ListIterator
• 示例：遍历ArrayList

import java.util.ArrayList;
import java.util.Iterator;public class JavaIteratorExample {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("A");list.add("B");Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}
}

2. Hibernate 的迭代器（ScrollableResults）

• 用于处理大量数据查询，避免一次性加载全部数据到内存

Session session = sessionFactory.openSession();
Query query = session.createQuery("from User");
ScrollableResults results = query.scroll();
while (results.next()) {User user = (User) results.get(0);// 处理用户数据
}
results.close();

3. Python 中的迭代器与生成器

• 迭代器协议：通过__iter__()和__next__()方法实现
• 生成器：使用yield关键字简化迭代器实现

# 生成器函数
def fibonacci():a, b = 0, 1while True:yield aa, b = b, a + b# 使用生成器
for num in fibonacci():if num > 100:breakprint(num)

五、避坑指南：正确使用迭代器模式的 3 个要点

1. 避免在迭代过程中修改聚合对象

• ❌ 反模式：在迭代器遍历过程中删除聚合元素（可能导致ConcurrentModificationException）
• ✅ 最佳实践：使用remove()方法（若迭代器支持），或先记录待删除元素，遍历结束后再操作。

2. 处理空聚合的边界情况

• 确保hasNext()在空聚合中返回false，next()在空聚合或遍历结束后抛出NoSuchElementException。

3. 迭代器的生命周期管理

• 避免迭代器被长时间持有，导致资源无法释放（如数据库游标未关闭）。
• 对于一次性遍历需求，可使用匿名内部类或局部内部类简化代码。

4. 反模式：过度封装简单遍历

• 对于简单的数组或集合遍历，直接使用for-each循环可能更简洁，无需引入迭代器模式。

六、总结：何时该用迭代器模式？

适用场景	核心特征	典型案例
遍历多种数据结构	数据存储结构复杂（如树、图），需统一遍历方式	文件系统目录遍历、数据库查询结果遍历
分离数据结构与遍历逻辑	避免客户端耦合具体数据结构实现细节	集合框架、ORM 框架
支持复杂遍历需求	需要实现倒序遍历、跳跃遍历、并发遍历等	大数据处理、多线程迭代

迭代器模式通过 “封装遍历 + 解耦结构” 的设计，使数据的访问与存储方式分离，提升了代码的可维护性和扩展性。下一篇我们将深入探讨装饰模式，解析如何在不修改原有类的基础上动态添加功能，敬请期待！

扩展思考：迭代器模式 vs 枚举（Enumeration）

模式	功能特性	线程安全	可修改性	典型应用
迭代器模式	支持删除、双向遍历、自定义遍历	需手动实现	支持	集合框架、复杂数据结构遍历
枚举	仅支持单向遍历，功能较简单	部分支持	不支持	早期 Java 集合遍历

理解这些差异，有助于在不同场景下选择合适的遍历方案。