设计模式-迭代器模式

迭代器模式（Iterator Pattern）解释

定义
迭代器模式是一种行为型设计模式，它提供了一种方法来顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

特点

• 分离遍历集合与集合本身的实现。
• 提供一种统一的方式来遍历不同类型的集合。
• 使得集合的实现和迭代逻辑分离。

迭代器模式的结构

1. 迭代器接口（Iterator）
   定义访问和遍历元素的方法，例如 hasNext() 和 next()。

2. 具体迭代器（Concrete Iterator）
   实现迭代器接口，负责遍历聚合对象中的元素。

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

4. 具体聚合（Concrete Aggregate）
   实现聚合接口，存储元素并提供创建具体迭代器的方法。

示例代码

以下用 Java 示例实现迭代器模式：

1. 定义迭代器接口

public interface Iterator<T> {
    boolean hasNext(); // 是否还有下一个元素
    T next();          // 返回下一个元素
}

2. 定义聚合接口

public interface Aggregate<T> {
    Iterator<T> createIterator(); // 创建迭代器
}

3. 实现具体聚合

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

public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<>();

    public void addItem(T item) {
        items.add(item);
    }

    public T getItem(int index) {
        return items.get(index);
    }

    public int size() {
        return items.size();
    }

    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(this);
    }
}

4. 实现具体迭代器

public class ConcreteIterator<T> implements Iterator<T> {
    private ConcreteAggregate<T> aggregate;
    private int currentIndex = 0;

    public ConcreteIterator(ConcreteAggregate<T> aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public boolean hasNext() {
        return currentIndex < aggregate.size();
    }

    @Override
    public T next() {
        return aggregate.getItem(currentIndex++);
    }
}

5. 测试迭代器模式

public class IteratorPatternDemo {
    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());
        }
    }
}

输出结果

Item 1
Item 2
Item 3

迭代器模式的优点

1. 封装性好：迭代器将集合的遍历逻辑封装起来，用户无需了解集合的内部结构。
2. 扩展性高：可以为不同的聚合对象提供不同的迭代器实现。
3. 统一接口：使用统一的接口来遍历不同类型的集合，增强了代码的可复用性。

适用场景

• 需要遍历一个复杂对象的所有元素而不暴露其内部实现时。
• 需要提供多种遍历方式（例如前序、中序、后序遍历）的场景。
• 需要让多个迭代器同时工作在同一个聚合对象上。

通过以上实现，迭代器模式将遍历逻辑与聚合对象的存储逻辑分离，提供了一种优雅的遍历方式，方便代码维护和扩展。