Java的设计模式——迭代器模式

介绍

迭代器模式是一种常用的设计模式，它提供了一种可以访问聚合对象元素的方式，而不用暴露聚合对象的内部表示。

使用场景

迭代器模式通常适用于以下情况：

• 需要访问一个聚合对象，而且不管聚合对象是什么都需要一个统一的接口来访问。
• 需要遍历一组数据结构，同时需要能够动态地变化，即不使用固定的索引来访问。

实现原理

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

• 抽象聚合类：定义一组抽象方法，用于访问聚合对象的元素。
• 具体聚合类：实现抽象聚合类中定义的方法，返回具体的迭代器实例。
• 抽象迭代器：定义一组抽象方法，用于访问聚合对象的元素。
• 具体迭代器：实现抽象迭代器中定义的方法，以适配具体聚合类。

具体实现可以参考下面的代码示例：

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

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

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

    public void remove(Object obj) {
        list.remove(obj);
    }

    public Object get(int index) {
        return list.get(index);
    }

    public int getSize() {
        return list.size();
    }

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

// 抽象迭代器
interface Iterator {
    Object first();

    Object next();

    boolean hasNext();
}

// 具体迭代器
class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int index = 0;

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

    @Override
    public Object first() {
        return aggregate.get(0);
    }

    @Override
    public Object next() {
        Object obj = null;
        index++;
        if (index < aggregate.getSize()) {
            obj = aggregate.get(index);
        }
        return obj;
    }

    @Override
    public boolean hasNext() {
        return index < aggregate.getSize() - 1;
    }
}

优点

• 访问聚合对象的方法统一，简化了客户端的调用流程。
• 隐藏了聚合对象的组成细节，增强了安全性。
• 支持增加新的聚合对象和迭代器，扩展性良好。

缺点

• 对于简单的聚合对象，使用迭代器模式会增加系统的复杂度。
• 由于需要额外的迭代器对象，增加了系统的内存开销。

参考资料

• 《设计模式：可复用面向对象软件的基础》
• Java迭代器模式详解