设计模式一迭代器模式

迭代器（Iterator）模式的定义：
　　提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
　　迭代器模式是一种对象行为型模式，
　　在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节

抽象聚合（Aggregate）角色：
 　 定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
具体聚合（ConcreteAggregate）角色：
 　 实现抽象聚合类，返回一个具体迭代器的实例。
抽象迭代器（Iterator）角色：
 　 定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
具体迭代器（Concretelterator）角色：
　　实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

public class Iterator {
    public static void main(String[] args) {
        ConcreteAggregate a = new ConcreteAggregate();
        a.add(1);
        a.add("小花");
        a.add(1.1);
        a.remove(1);
        Iteratoring iterator = a.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

// 抽象迭代器
interface Iteratoring {
    public boolean hasNext();

    public Object next();
}

//具体迭代器
class Concretelterator implements Iteratoring {

    private ArrayList<Object> li;

    public Concretelterator(ArrayList<Object> li) {
        this.li = li;
    }

    int count = 0;

    @Override
    public boolean hasNext() {
        if (count < li.size()) {
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        if (hasNext()) {
            return li.get(count++);
        }
        return null;
    }
}

//抽象聚合
interface Aggregate {
    public void add(Object obj);

    public void remove(Object obj);

    public Iteratoring getIterator();
}

//具体聚合
class ConcreteAggregate implements Aggregate {

    private ArrayList arr = new ArrayList();

    @Override
    public void add(Object obj) {
        arr.add(obj);
    }

    @Override
    public void remove(Object obj) {
        arr.remove(obj);
    }

    @Override
    public Iteratoring getIterator() {
        return new Concretelterator(arr);
    }
}