[23种设计模式][行为型]05.迭代器模式

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第5天，点击查看活动详情

1.迭代器模式意图：

提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露对象的内部表示。

2.迭代器模式的适用性：

• 访问一个聚合对象的内容而无需暴露它的内部表示。
• 支持对聚合对象的多种遍历。
• 为遍历不同的聚合结构提供一个统一的接口（即支持多态迭代）。

3.迭代器（Iterator）模式的构成：

1. 抽象迭代器（Iterator）角色：此抽象角色定义出遍历元素所需的接口
2. 具体迭代器（ConcreteIterator）角色：此角色实现了Iterator接口，并保持迭代过程中游标的位置
3. 聚集（Aggregate）角色：此抽象角色给出创建迭代器（Iterator）对象的接口
4. 具体聚集（ConcreteAggregate）角色：实现了创建迭代器（Iterator）对象的接口，返回一个合适的具体迭代器实例
5. 客户端（Client）角色：持有对聚集及其迭代子对象的引用，调用迭代子对象的迭代接口，也有可能通过迭代器操作聚集元素的增加和删除

4. 迭代器模式UML图：

5.迭代器模式时序图：

6.代码示例：

客户端：

public class Client {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();

        aggregate.set(0, "Item A");
        aggregate.set(1, "Item B");
        aggregate.set(2, "Item C");
        aggregate.set(3, "Item D");

        MyIterator iterator = new ConcreteIterator(aggregate);

        Object first = iterator.first();
        System.out.println("First Element: " + first);

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

聚集角色：

public abstract class Aggregate {

    public abstract MyIterator createIterator();
}

具体聚集角色：

public class ConcreteAggregate extends Aggregate {

    private ArrayList<Object> list = new ArrayList<>();

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

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

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

    public void set(int index, Object object) {
        list.add(index, object);
    }
}

具体迭代器角色：

public class ConcreteIterator extends MyIterator {

    private ConcreteAggregate aggregate;
    private int current = 0;

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

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

    @Override
    public Object next() {
        return aggregate.get(current++);
    }

    @Override
    public boolean hasNext() {
        return current != aggregate.count();
    }

    @Override
    public Object currentItem() {
        return current;
    }
}

迭代器角色：

public abstract class MyIterator {

    public abstract Object first();

    public abstract Object next();

    public abstract boolean hasNext();

    public abstract Object currentItem();
}