迭代器模式

一、模式简介

定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
场景：遍历不同的聚合结构提供统一的接口。访问聚合对象的内容而无须暴露其内部细节的表示。

• 角色结构：
• 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
• 具体聚合（Concrete Aggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
• 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口。
• 具体迭代器（Concrete lterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

二、模式实现

public interface AbstractAggregate { -> 抽象聚合
    void add(Object o);
    void remove(Object o);
    AbstractIterator iterator();
}

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

    @Override
    public void add(Object o) {
        list.add(o);
    }

    @Override
    public void remove(Object o) {
        list.remove(o);
    }

    @Override
    public AbstractIterator iterator() {
        return new ConcreteIterator(list);
    }
}

public interface AbstractIterator { -> 抽象迭代
    Object first();
    Object next();
    boolean hasNext();
}

public class ConcreteIterator implements AbstractIterator { -> 具体迭代
    private List<Object> list;
    private int index = -1;

    public ConcreteIterator(List<Object> list) {
        if (list != null) {
            this.list = list;
        } else {
            this.list = new ArrayList<>();
        }
    }

    @Override
    public Object first() {
        return list.size() > 0 ? list.get(0) : null;
    }

    @Override
    public Object next() {
        return hasNext() ? list.get(++index) : null;
    }

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

以遍历集合输出每个元素的信息为例子

AbstractAggregate aggregate = new ConcreteAggregate();
aggregate.add("w");
aggregate.add("j");
aggregate.add("x");
AbstractIterator iterator = aggregate.iterator();
while (iterator.hasNext()){
    System.out.println(iterator.next().toString());
}