迭代器模式

       迭代器模式提供一种方法顺序访问聚合对象中的各个元素而又不暴露其内部的表示。把游走的任务放在迭代器上而不是聚合上。简化聚合的接口和实现，让责任各得其所。

　　

　　迭代器模式涉及到以下几个角色：

       抽象迭代器(Iterator)角色：定义出遍历元素所需的接口

       具体迭代器(ConcreteIterator)角色：实现Iterator接口，并保持迭代过程中的游标位置

       聚集(Aggregate)角色：给出创建迭代器(Iterator)对象的接口

       具体聚集(ConcreteAggregate)角色：实现创建迭代器(Iterator)对象的接口，返回一个合适的具体迭代器实例

       客户端(Client)角色：持有对聚集及其迭代器对象的引用，调用迭代子对象的迭代接口，也有可能通过迭代子操作聚集元素的增加和删除

　　抽象聚集角色类，规定出所有的具体聚集必须实现的接口。迭代器模式要求聚集对象必须有一个工厂方法，就是createIterator()方法，以向外界提供迭代器对象的实例

public abstract class Aggregate {

    /**
     * 工厂方法，创建迭代对象的接口
     *
     * @return
     */
    public abstract Iterator createIterator();
}

       具体聚集角色类，实现抽象聚集角色类所要求的接口，就是createIterator()方法。此外，还有方法getElement()向外界提供聚集元素，而方法size()向外界提供聚集的大小等。

 

public class ConcreteAggregate extends Aggregate {

    private Object[] values;

    public ConcreteAggregate(Object[] values) {
        this.values = values;
    }

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

    public Object getElement(int index) {
        if (index < values.length) {
            return values[index];
        } else {
            return null;
        }
    }

    public int size() {
        return values.length;
    }
}

抽象迭代器角色类

public interface Iterator {

    /**
     * 迭代方法：移动到第一个元素
     */
    void first();

    /**
     * 迭代方法：移动到下一个元素
     */
    void next();

    /**
     * 迭代方法：是否为最后一个元素
     */
    boolean hasNext();

    /**
     * 迭代方法：返还当前元素
     */
    Object currentItem();
}

具体迭代器角色类

public class ConcreteIterator implements Iterator {

    private ConcreteAggregate aggregate;
    private int size;
    private int index;

    public ConcreteIterator(ConcreteAggregate concreteAggregate) {
        aggregate = concreteAggregate;
        size = concreteAggregate.size();
        index = 0;
    }

    @Override
    public void first() {
        index = 0;
    }

    @Override
    public void next() {
        index++;
    }

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

    @Override
    public Object currentItem() {
        return aggregate.getElement(index);
    }
}

测试类

@Slf4j
public class IteratorTest {

    public static void main(String[] args) {
        Object[] objArray = {"One", "Two", "Three", "Four", "Five", "Six"};
        Aggregate agg = new ConcreteAggregate(objArray);
        Iterator it = agg.createIterator();
        while (it.hasNext()) {
            log.info("元素:{}", it.currentItem());
            it.next();
        }
    }
}

迭代器模式的优缺点

优点

　　①简化了遍历方式

　　②可以提供多种遍历方式，比如说对有序列表，可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历。

　　③封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。

缺点

　　对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐