设计模式15 -- 迭代器模式

迭代器模式（Iterator Pattern）是一种行为型设计模式，它的核心是提供一种统一的方式遍历聚合对象（如集合、列表）中的元素，同时隐藏聚合对象的内部结构。通过引入 “迭代器” 角色，将 “遍历逻辑” 与 “聚合对象” 解耦，让聚合对象无需暴露内部实现即可支持遍历。

简单来说，迭代器模式就像 “快递员取件”—— 快递员（迭代器）按固定流程（hasNext()判断是否有件、next()取件）从快递柜（聚合对象）取件，无需知道快递柜内部的分层、分区结构，只需按统一接口操作。

迭代器模式的UML如下:

下面我将用 Java 代码实现迭代器模式，展示其核心结构和工作原理。这个示例将创建一个简单的集合类和对应的迭代器，实现对元素的遍历。

Iterator 接口：定义了迭代器的基本操作，hasNext()用于判断是否还有下一个元素，next()用于获取下一个元素。

// 抽象迭代器接口
public interface Iterator {
    boolean hasNext();
    Object next();
}

Aggregate 接口：定义了聚合对象的基本操作，包括创建迭代器的createIterator()方法，以及添加元素、获取大小等方法。

// 抽象聚合接口
public interface Aggregate {
    Iterator createIterator();
    void add(Object element);
    int getSize();
    Object getElement(int index);
}

ConcreteIterator 类：实现了 Iterator 接口，负责具体的遍历逻辑。它持有一个对具体聚合对象的引用，并维护当前遍历的索引位置。

// 具体迭代器
public class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int currentIndex;
    
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
        this.currentIndex = 0;
    }
    
    @Override
    public boolean hasNext() {
        return currentIndex < aggregate.getSize();
    }
    
    @Override
    public Object next() {
        if (hasNext()) {
            return aggregate.getElement(currentIndex++);
        }
        return null;
    }
}

ConcreteAggregate 类：实现了 Aggregate 接口，是具体的聚合对象。它内部使用 ArrayList 存储元素，并实现了创建迭代器的方法。

// 具体聚合
import java.util.ArrayList;
import java.util.List;

public class ConcreteAggregate implements Aggregate {
    private List<Object> elements;
    
    public ConcreteAggregate() {
        elements = new ArrayList<>();
    }
    
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
    
    @Override
    public void add(Object element) {
        elements.add(element);
    }
    
    @Override
    public int getSize() {
        return elements.size();
    }
    
    @Override
    public Object getElement(int index) {
        return elements.get(index);
    }
}

Client 类：演示了如何使用迭代器模式。客户端只需通过聚合对象获取迭代器，然后使用迭代器进行遍历，无需了解聚合对象的内部结构。

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建聚合对象并添加元素
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("元素1");
        aggregate.add("元素2");
        aggregate.add("元素3");
        aggregate.add("元素4");
        
        // 获取迭代器并遍历
        Iterator iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            Object element = iterator.next();
            System.out.println("遍历元素: " + element);
        }
    }
}

上面的代码中

客户端创建聚合对象并添加元素
客户端通过聚合对象的createIterator()方法获取迭代器
客户端使用迭代器的hasNext()和next()方法遍历聚合中的元素
迭代器负责跟踪当前遍历位置，并从聚合中获取相应元素

迭代器模式的优势如下：

避免迭代器失效：若在遍历过程中修改聚合对象（如添加 / 删除元素），可能导致迭代器 “失效”（如索引错乱），需在迭代器中处理（如快速失败机制，Java 的 ConcurrentModificationException）。
简化设计：若聚合对象结构简单（如固定大小的数组），且无需多种遍历方式，可直接在聚合类中实现遍历逻辑，避免过度设计。
语言原生支持：多数高级语言（Java、C#、Python）已内置迭代器模式（如 Java 的 Iterator 接口、Python 的 __iter__ 和 __next__ 方法），实际开发中优先使用原生迭代器，无需重复造轮子。