迭代模式（Inerator Pattern）

迭代（Iterator）模式的定义与特点

定义：
提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部标识。
迭代器模式属于行为型模式。

优点：
1.访问一个聚合对象的内容而无需暴露它的内部表示。
2.便利任务交由迭代器完成，这简化了聚合类。
3.他支持以不同方式便利一个聚合，甚至可以自己定义迭代器的子类已支持新的便利。
4.增加新的聚合类和迭代器类都很方便，无需修改原有代码。
5.封装性好，为便利不同的聚合结构提供一个统一的接口。

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

模式的角色

1.抽象聚合（Aggreadte）角色：定义存储，添加，删除聚合对象以及创建迭代器对象的接口。
2.具体聚合（Concrete Aggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3.抽象迭代器（Iterator）角色：定义访问和便利聚合元素的接口，通常包含 hastNext(),first(),next()等方法。
4.具体迭代器（Concrete Iterator）角色：实现抽象迭代器接口中所有定义的方法，完成对聚合对象的便利，记录便利的当前位置。

迭代器模式的实现

创建抽象迭代器定义访问和便利聚合元素的接口，通常包含 hastNext(),first(),next()等方法

/**
 * 抽象迭代：定义访问聚合元素的接口，通常包含 first(), next(), hasNext()
 */
public interface Iterator {

    // 获取第一个元素
    Object first();
    // 获取当前元素
    Object next();
    // 是否有下一个元素
    boolean hasNext();
}

创建具体迭代器实现抽象迭代器的方法，完成对聚合对象的便利

/**
 * 具体迭代器：实现抽象迭代器的方法，完成对聚合对象的便利，记录便利的当前位置
 */
public class ConcreteIterator implements Iterator{

    // 用于接收具体聚合
    private List<Object> list = null;

    // 记录元素当前下标
    private int index = -1;

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

    // 获取第一个元素
    @Override
    public Object first() {
        return list.get(0);
    }

    // 获取当前元素
    @Override
    public Object next() {
        Object obj = null;
        if(this.hasNext()){
           obj = list.get(++index);
        }
        return obj;
    }

    // 判断是否还有元素
    @Override
    public boolean hasNext() {
        if(this.index < list.size() - 1){
            return true;
        }
        return false;
    }
}

创建抽象聚合类，定义添加，存储，删除聚合对象并创建迭代器的接口

/**
 * 抽象聚合：定义存储，添加，删除聚合对象以及创建迭代器的接口
 */
public interface Aggregate {

    // 添加元素
    public void add(Object obj);
    // 删除元素
    public void remove(Object obj);
    // 获取地带器
    public Iterator getInerator();
}

创建具体聚合类，实现抽象聚合类的方法，返回一个具体迭代器实例

/**
 * 具体聚合：实现抽象聚合类，返回一个具体迭代器实例
 */
public class ConcreteAggregate implements Aggregate{

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

    // 添加元素
    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    // 删除元素
    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

    // 返回具体迭代器
    @Override
    public Iterator getInerator() {
        return new ConcreteIterator(list);
    }
}

调用测试

    public static void main(String[] args) {
        // 创建聚合类 添加聚合元素
        Aggregate ag = new ConcreteAggregate();
        ag.add("A");
        ag.add("B");
        ag.add("C");
        ag.add("D");
        ag.add("E");
        // 获取具体迭代器
        Iterator inerator = ag.getInerator();
        while (inerator.hasNext()){
            System.out.println(inerator.next());
        }
        System.out.println("第一个元素是："+inerator.first());
    }

结果

A
B
C
D
E
第一个元素是：A