设计模式之迭代器模式

迭代器模式详解

迭代器模式是一种行为设计模式，提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。迭代器模式将遍历元素的责任交给迭代器，而不是聚合对象，从而简化了聚合对象的接口和实现。

1. 模式结构

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

• Iterator（迭代器）： 定义访问和遍历元素的接口。

• ConcreteIterator（具体迭代器）： 实现迭代器接口，负责实现具体的遍历算法。

• Aggregate（聚合）： 定义创建相应迭代器对象的接口。

• ConcreteAggregate（具体聚合）： 实现创建相应迭代器对象的方法，返回具体迭代器的实例。

2. 优缺点比较

优点	缺点
支持以不同方式遍历一个聚合对象	聚合对象的类型和具体迭代器类之间耦合度较高
简化了聚合类	具体迭代器类的增加和修改可能对聚合类产生影响
封装了遍历元素的细节

3. 使用场景

迭代器模式通常在以下情况下使用：

• 访问一个聚合对象的内容而无需暴露其内部表示。
• 支持对聚合对象的多种遍历。
• 提供一个统一的接口，用于遍历不同类型的聚合对象。

4. 示例代码

// 1. Iterator 迭代器
public interface Iterator<T> {
    boolean hasNext();
    T next();
}

// 2. ConcreteIterator 具体迭代器
public class ConcreteIterator<T> implements Iterator<T> {
    private List<T> list;
    private int index = 0;

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

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

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

// 3. Aggregate 聚合
public interface Aggregate<T> {
    Iterator<T> createIterator();
}

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

    public void add(T element) {
        list.add(element);
    }

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

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

        Iterator<String> iterator = aggregate.createIterator();

        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

以上示例中，ConcreteIterator 实现了 Iterator 接口，负责遍历具体聚合对象中的元素。ConcreteAggregate 实现了 Aggregate 接口，提供创建迭代器的方法。客户端通过具体聚合对象创建迭代器，并使用迭代器遍历元素。