迭代器模式是一种行为设计模式，它提供了一种统一的方式来遍历集合对象中的元素，而无需暴露其底层实现细节，通过将遍历逻辑封装到独立的迭代器对象中，该模式实现了集合结构与遍历操作的解耦，支持多种遍历方式（如顺序、逆序或过滤遍历）的同时保持代码简洁。 ，核心思想在于定义Iterator接口（通常包含hasNext()和next()方法），由具体迭代器实现针对不同集合（如列表、树）的遍历逻辑，集合类则通过createIterator()方法返回对应的迭代器实例，这种模式广泛应用于Java的Collection框架、数据库查询结果集等场景，其优点是增强代码的灵活性和可扩展性，但可能因引入额外对象增加系统复杂度。

在软件开发中,我们经常需要处理各种集合数据，如数组、列表、树、图等，如何高效、统一地遍历这些集合，而不暴露其内部结构，是一个常见的设计挑战，迭代器模式（Iterator Pattern）正是为解决这一问题而生的设计模式，本文将深入探讨迭代器模式的定义、实现方式、优缺点以及实际应用场景，帮助开发者更好地掌握这一模式。

---

什么是迭代器模式？

迭代器模式是一种行为型设计模式,它提供了一种方法来顺序访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示，换句话说，迭代器模式将遍历集合的责任从集合对象中分离出来，交给一个专门的迭代器对象处理。

迭代器模式的核心思想是：

• 分离遍历逻辑：将遍历集合的逻辑从集合类中抽离，使集合类专注于数据存储和管理。
• 统一访问接口：为不同类型的集合提供一致的遍历方式，简化客户端代码。

---

迭代器模式的结构

迭代器模式通常包含以下几个角色：

1. Iterator（迭代器接口）
   定义遍历集合所需的操作，如 next()、hasNext()、current() 等。

2. ConcreteIterator（具体迭代器）
   实现迭代器接口，负责管理当前遍历的位置，并提供具体的遍历逻辑。

3. Aggregate（聚合接口）
   定义创建迭代器的方法，如 createIterator()。

4. ConcreteAggregate（具体聚合类）
   实现聚合接口，返回一个与该集合对应的具体迭代器。

UML 类图示例

+----------------+       +----------------+
|   Aggregate    |       |    Iterator    |
+----------------+       +----------------+
| +createIterator|<>-----| +next()        |
+----------------+       | +hasNext()     |
                         +----------------+
                                ^
                                |
                +---------------+---------------+
                |                               |
        +----------------+             +----------------+
        | ConcreteAggregate|             | ConcreteIterator|
        +----------------+             +----------------+
        | +createIterator|             | +next()        |
        +----------------+             | +hasNext()     |
                                        +----------------+

---

迭代器模式的实现

以下是一个简单的迭代器模式实现示例（使用 Java）：

（1）定义迭代器接口

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

（2）定义聚合接口

public interface Aggregate<T> {
    Iterator<T> createIterator();
}

（3）实现具体聚合类

public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<>();
    public void addItem(T item) {
        items.add(item);
    }
    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(items);
    }
}

（4）实现具体迭代器

public class ConcreteIterator<T> implements Iterator<T> {
    private List<T> items;
    private int position = 0;
    public ConcreteIterator(List<T> items) {
        this.items = items;
    }
    @Override
    public boolean hasNext() {
        return position < items.size();
    }
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return items.get(position++);
    }
}

（5）客户端使用

public class Client {
    public static void main(String[] args) {
        ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.addItem("Item 1");
        aggregate.addItem("Item 2");
        aggregate.addItem("Item 3");
        Iterator<String> iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

---

迭代器模式的优缺点

优点

1. 单一职责原则：将遍历逻辑与集合类分离，使代码更清晰。
2. 开闭原则：可以新增迭代器而不修改集合类。
3. 支持并行遍历：多个迭代器可以同时遍历同一个集合。
4. 隐藏实现细节：客户端无需知道集合的内部结构。

缺点

1. 增加代码复杂度：对于简单的集合，使用迭代器可能显得冗余。
2. 性能开销：某些情况下，迭代器的抽象可能带来轻微的性能损耗。

---

迭代器模式的应用场景

迭代器模式在以下场景中特别有用：

• 需要统一遍历不同结构的集合（如数组、链表、树）。
• 希望隐藏集合的内部实现，提供一致的访问方式。
• 支持多种遍历方式（如正向、反向、跳跃遍历）。
• 在集合类库中广泛应用（如 Java 的 Iterator、Python 的 iter()）。

实际案例

• Java 集合框架：List、Set 等集合类都实现了 Iterable 接口，提供 iterator() 方法。
• 数据库查询结果遍历：JDBC 的 ResultSet 可以看作一个迭代器。
• 文件逐行读取：BufferedReader 的 lines() 方法返回一个迭代器。

---

迭代器模式与其他模式的关系

• 与组合模式结合：用于遍历树形结构（如文件系统）。
• 与工厂方法模式结合：由聚合类决定返回哪种迭代器。
• 与访问者模式对比：迭代器关注遍历，访问者关注对元素的操作。

---

迭代器模式是一种强大的设计模式,它通过将遍历逻辑与集合分离，提高了代码的灵活性和可维护性，尽管在某些简单场景下可能显得“过度设计”，但在需要处理复杂集合或提供统一遍历方式时，它仍然是一个极佳的选择，掌握迭代器模式，可以帮助开发者编写更优雅、更易于扩展的代码。

---

参考文献

• 《设计模式：可复用面向对象软件的基础》（GoF）
• 《Head First 设计模式》
• Java Iterator 官方文档

希望本文能帮助你深入理解迭代器模式,并在实际开发中灵活运用！