迭代器模式（Iterator Pattern）

迭代器模式（Iterator Pattern）是一种行为设计模式，它提供了一种方法来顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。下面从多个方面详细介绍迭代器模式。

模式结构与角色

迭代器模式主要包含以下几个角色：

1. 抽象迭代器（Iterator）：定义了访问和遍历元素的接口，通常包含 hasNext() 方法用于判断是否还有下一个元素，next() 方法用于返回下一个元素。
2. 具体迭代器（Concrete Iterator）：实现了抽象迭代器接口，负责具体的元素遍历逻辑，跟踪聚合对象中的当前位置。
3. 抽象聚合（Aggregate）：定义了创建迭代器对象的接口，通常包含 createIterator() 方法。
4. 具体聚合（Concrete Aggregate）：实现了抽象聚合接口，负责创建具体的迭代器对象，返回一个与该聚合对象对应的迭代器实例。

代码示例

以下是一个简单的迭代器模式示例，模拟一个自定义的集合类，并使用迭代器来遍历集合中的元素：

import java.util.ArrayList;
import java.util.List;

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

// 具体迭代器
class ConcreteIterator implements Iterator {
    private List<Object> list;
    private int position = 0;

    public ConcreteIterator(List<Object> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return position < list.size();
    }

    @Override
    public Object next() {
        if (hasNext()) {
            return list.get(position++);
        }
        return null;
    }
}

// 抽象聚合
interface Aggregate {
    Iterator createIterator();
}

// 具体聚合
class ConcreteAggregate implements Aggregate {
    private List<Object> list = new ArrayList<>();

    public void add(Object item) {
        list.add(item);
    }

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(list);
    }
}

// 客户端代码
public class IteratorPatternExample {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.add("Item 1");
        aggregate.add("Item 2");
        aggregate.add("Item 3");

        Iterator iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

代码解释

1. 抽象迭代器 Iterator：定义了 hasNext() 和 next() 两个方法，用于判断是否还有下一个元素以及获取下一个元素。
2. 具体迭代器 ConcreteIterator：实现了 Iterator 接口，使用一个 List 来存储要遍历的元素，通过 position 变量跟踪当前位置。
3. 抽象聚合 Aggregate：定义了 createIterator() 方法，用于创建迭代器对象。
4. 具体聚合 ConcreteAggregate：实现了 Aggregate 接口，使用一个 List 来存储元素，并在 createIterator() 方法中返回一个具体的迭代器实例。
5. 客户端代码：创建了一个具体聚合对象，添加了一些元素，然后获取迭代器并遍历元素。

优点

1. 简化聚合对象的接口：迭代器模式将遍历逻辑从聚合对象中分离出来，使得聚合对象的接口更加简洁，只需要关注元素的存储和管理。
2. 支持多种遍历方式：可以为同一个聚合对象提供不同的迭代器实现，以支持不同的遍历方式，例如正向遍历、反向遍历等。
3. 提高代码的可维护性和可扩展性：当需要修改遍历逻辑或添加新的遍历方式时，只需要修改或添加具体的迭代器类，而不需要修改聚合对象的代码。

缺点

1. 增加类的数量：引入迭代器模式会增加抽象迭代器、具体迭代器等类，使得系统的类数量增多，增加了系统的复杂度。
2. 不适合简单的遍历场景：对于简单的集合遍历，使用迭代器模式可能会显得过于繁琐，不如直接使用 for 循环简洁。

应用场景

1. 需要对聚合对象进行多种方式遍历的场景：例如，在一个树形结构中，可能需要前序遍历、中序遍历、后序遍历等多种遍历方式，可以为每种遍历方式创建一个具体的迭代器。
2. 需要隐藏聚合对象内部表示的场景：迭代器模式可以将聚合对象的内部表示隐藏起来，只提供统一的遍历接口，使得客户端不需要关心聚合对象的具体实现。
3. 需要为不同的聚合对象提供统一遍历接口的场景：当有多个不同类型的聚合对象需要遍历，并且希望使用统一的方式进行遍历时，可以使用迭代器模式。