迭代器模式深度解析与实战案例

一、模式定义

迭代器模式（Iterator Pattern）是一种行为设计模式，提供一种方法顺序访问聚合对象的元素，无需暴露其底层表示。核心思想是将遍历逻辑从聚合对象中分离，实现遍历与存储的解耦。

二、核心组件

组件	作用
Iterator	定义遍历接口（hasNext/next）
ConcreteIterator	实现具体集合的遍历逻辑
Aggregate	聚合对象接口，定义创建迭代器的方法
ConcreteAggregate	具体聚合对象，实现迭代器创建方法

三、模式优势

统一遍历接口：不同集合使用相同方式遍历
单一职责原则：分离集合管理与遍历算法
开闭原则：新增迭代器类型不影响现有代码
并行遍历：支持多个迭代器同时遍历集合

四、真实场景案例：社交网络关系遍历

场景需求
某社交平台需要实现：
用户关系包含好友列表（数组存储）和关注列表（链表存储）
需要统一接口遍历两种关系
支持隐私过滤（不展示已注销用户）

五、Java实现代码

1. 迭代器接口

public interface RelationIterator<T> {boolean hasNext();T next();void remove();
}

2. 聚合对象接口

public interface SocialNetwork {RelationIterator<User> createIterator();RelationIterator<User> createActiveUserIterator(); // 扩展：过滤非活跃用户
}

3. 具体聚合对象实现

// 好友列表（数组存储）
class FriendList implements SocialNetwork {private User[] friends;private int size;public FriendList(int capacity) {friends = new User[capacity];}public void addFriend(User user) {if (size < friends.length) {friends[size++] = user;}}@Overridepublic RelationIterator<User> createIterator() {return new FriendListIterator();}@Overridepublic RelationIterator<User> createActiveUserIterator() {return new ActiveFriendListIterator();}// 具体迭代器实现（内部类）private class FriendListIterator implements RelationIterator<User> {private int position = 0;@Overridepublic boolean hasNext() {return position < size;}@Overridepublic User next() {if (!hasNext()) throw new NoSuchElementException();return friends[position++];}@Overridepublic void remove() {throw new UnsupportedOperationException();}}// 扩展：过滤非活跃用户private class ActiveFriendListIterator implements RelationIterator<User> {private int position = 0;@Overridepublic boolean hasNext() {skipInactiveUsers();return position < size;}@Overridepublic User next() {if (!hasNext()) throw new NoSuchElementException();return friends[position++];}private void skipInactiveUsers() {while (position < size && !friends[position].isActive()) {position++;}}}
}// 关注列表（链表存储）
class FollowingList implements SocialNetwork {private static class Node {User user;Node next;Node(User user) {this.user = user;}}private Node head;private Node tail;public void addFollowing(User user) {Node newNode = new Node(user);if (head == null) {head = tail = newNode;} else {tail.next = newNode;tail = newNode;}}@Overridepublic RelationIterator<User> createIterator() {return new FollowingListIterator();}// 具体迭代器实现（内部类）private class FollowingListIterator implements RelationIterator<User> {private Node current = head;@Overridepublic boolean hasNext() {return current != null;}@Overridepublic User next() {if (!hasNext()) throw new NoSuchElementException();User user = current.user;current = current.next;return user;}@Overridepublic void remove() {throw new UnsupportedOperationException();}}
}

4. 用户实体类

public class User {private final String id;private String name;private boolean active = true;public User(String id, String name) {this.id = id;this.name = name;}// Getters/Setterspublic boolean isActive() { return active; }public void deactivate() { active = false; }
}

5. 客户端使用

public class SocialNetworkClient {public static void main(String[] args) {// 初始化数据User user1 = new User("U001", "张三");User user2 = new User("U002", "李四");user2.deactivate();User user3 = new User("U003", "王五");// 构建好友列表FriendList friends = new FriendList(10);friends.addFriend(user1);friends.addFriend(user2);friends.addFriend(user3);// 构建关注列表FollowingList followings = new FollowingList();followings.addFollowing(user3);followings.addFollowing(user1);// 遍历好友列表（基础迭代器）System.out.println("=== 好友列表 ===");printRelations(friends.createIterator());// 遍历关注列表System.out.println("\n=== 关注列表 ===");printRelations(followings.createIterator());// 使用过滤迭代器System.out.println("\n=== 活跃好友 ===");printRelations(friends.createActiveUserIterator());}private static void printRelations(RelationIterator<User> iterator) {while (iterator.hasNext()) {User user = iterator.next();System.out.printf("%s (%s)%n", user.getName(), user.isActive() ? "活跃" : "已注销");}}
}

六、运行结果

=== 好友列表 ===
张三 (活跃)
李四 (已注销)
王五 (活跃)=== 关注列表 ===
王五 (活跃)
张三 (活跃)=== 活跃好友 ===
张三 (活跃)
王五 (活跃)

七、模式变体与优化

1. 多维度迭代

// 组合条件迭代器
public interface CompositeIterator<T> extends RelationIterator<T> {void addFilter(Predicate<T> filter);void sort(Comparator<T> comparator);
}// 使用示例
CompositeIterator<User> iterator = new SmartUserIterator();
iterator.addFilter(User::isVIP);
iterator.sort(Comparator.comparing(User::getJoinDate));

2. 线程安全实现

// 快照迭代器（避免ConcurrentModificationException）
public class SnapshotIterator<T> implements RelationIterator<T> {private final List<T> snapshot;private int position = 0;public SnapshotIterator(Collection<T> original) {this.snapshot = new ArrayList<>(original);}// 实现标准迭代器方法...
}

八、行业应用场景

场景	具体应用	优势体现
文件系统遍历	递归遍历目录结构	统一处理文件/文件夹
数据库查询	结果集游标遍历	处理海量数据内存优化
游戏物品系统	背包不同分类物品遍历	支持多种筛选条件
大数据处理	分片数据顺序访问	处理超出内存限制的数据
GUI组件树遍历	窗口组件层级遍历	支持深度优先/广度优先策略

九、最佳实践建议

迭代器生命周期管理

// 使用try-with-resources管理资源
try (RelationIterator<User> iterator = friends.createIterator()) {while (iterator.hasNext()) {// 处理逻辑}
}

空迭代器实现

// 空对象模式应用
public class EmptyIterator<T> implements RelationIterator<T> {@Override public boolean hasNext() { return false; }@Override public T next() { throw new NoSuchElementException(); }
}

性能优化技巧

// 预计算迭代路径（适用于树形结构）
public class PrecomputedTreeIterator<T> implements RelationIterator<T> {private final List<T> traversalPath;private int index = 0;public PrecomputedTreeIterator(TreeNode root) {this.traversalPath = preorderTraversal(root);}// 实现标准方法...
}

十、与相似模式对比

模式	核心差异	适用场景
迭代器	专注集合遍历机制	需要统一遍历接口的场景
访问者	在遍历过程中执行操作	对集合元素进行复杂操作
组合	处理树形结构	需要递归遍历的层级结构
工厂方法	用于创建迭代器对象	需要灵活创建不同类型迭代器