《迭代器模式》

一、什么是迭代器模式？

（一）为什么要有迭代器模式？
在程序设计中，经常需要访问一个聚合对象的各个元素，诸如数组、列表的遍历，这时候，我们都把创建表和遍历表都放在一个类中，一旦需要修改遍历方式，就需要修改整个类，不利于扩展，这违反了“开闭原则”。

（二）迭代器（Iterator）模式的定义：
提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

二、如何实现迭代器模式？

以下将通过代码实现迭代器模式

public class IteratorDemo {
    public static void main(String[] args) {
        Concurrent concurrent = new Concurrent();
        concurrent.add("1");
        concurrent.add("2");
        concurrent.add("3");
        concurrent.add("4");
        Iterator iterator = concurrent.getIterator();
        boolean hasNext = iterator.hasNext();
        System.out.println("是否有下一个：" + hasNext);
        String first = (String)iterator.first();
        System.out.println("First:"+first);
        Object next = iterator.next();
        System.out.println("next:" + next);
        Object last = iterator.last();
        System.out.println("last:" + last);
    }
}

/**
 * 聚合抽象类
 */
interface Aggregate{
    void add(Object object);

    void remove(Object object);

    Iterator getIterator();
}

/**
 * 聚合实体类
 */
class Concurrent implements Aggregate {
    List<Object> list = new ArrayList<>();

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

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

    @Override
    public Iterator getIterator() {
        return (new ConcurrentIterator(list));
    }
}


/**
 * 迭代器抽象类
 */
interface Iterator{
    boolean hasNext();

    Object first();

    Object next();

    Object last();
}

/**
 * 具体迭代器类
 */
class ConcurrentIterator implements Iterator {
    private List<Object> list = null;
    private int index= -1;

    ConcurrentIterator(List<Object> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        if (list.size() > 0) {
            return true;
        }
        return false;
    }

    @Override
    public Object first() {
        index = 0;
        if (this.hasNext()) {
            return list.get(index);
        }
        return null;
    }

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

    @Override
    public Object last() {
        index = list.size() - 1;
        if (this.hasNext()) {
            return list.get(index);
        }
        return null;
    }
}

三、迭代器模式有什么优缺点？

迭代器模式的优点：

• 访问一个聚合对象的内容而无须暴露它的内部表示。
• 遍历任务交由迭代器完成，这简化了聚合类。
• 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
• 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
• 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点：

• 增加了类的个数，这在一定程度上增加了系统的复杂性。