行为型模式 06 迭代器模式

迭代器模式Iterator

提供一种方法顺序访问一个聚合对象中各个元素，而又不需要暴露该对的内部表示

Iterator：抽象迭代类，提供遍历所需的开始，下一个，当前是哪个，是否结束等统一接口
ConcreteIterator ：具体迭代类具体实现方法
Aggregate ：抽象聚集类，有创造Iterator的接口
ConcreteAggregate：时间接口，持有一个聚集元素集合

分离了聚集对象的遍历，由一个迭代器来负责，既不用暴露集合的内部结构，又可让外部代码透明底访问聚集内部数据

使用场景

1一个聚集对象（接口或抽象类集合），不管对象是那种子类都要对其进行遍历时，可考虑使用迭代器模式
2.需要对一个聚集有多种方式遍历时（遍历算法与聚集对象分离，两者可相互改变而不影响可为聚集对象添加多种聚集方式）

JaVA聚集对象即是实现了java.util.Collection接口的对象

实例

Aggregate：
有创建迭代器的窗口

public interface Aggregate {
    MyIterator createIterator();
}

ConcreteAggregate：
内部持有聚集对象，使用对象自身创造具体迭代器

public class ConcreteAggregate implements Aggregate{
    private List<? extends Object> list;
    public ConcreteAggregate(List<? extends Object> list ){
        this.list = list;
    }
    @Override
    public MyIterator createIterator() {
        return new ConcreteMyIterator(this);// 创建具体迭代器
    }
    public int count(){
        return this.list.size();
    }
    public Object getElement(int index){
        return list.get(index);
    }
}

Iterator：
有第一个，下一个，当前是哪个，是否结束等接口

public abstract class MyIterator {
    public abstract Object first();
    public abstract boolean isLast();
    public abstract void next();
    public abstract Object CurrentElement();
}

ConcreteMyIterator：
实现上述接口

public class ConcreteMyIterator extends MyIterator{
    protected ConcreteAggregate aggregate;
    private int index = 0;
    private int size=0;
    public ConcreteMyIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
        this.size = aggregate.count();
    }
    @Override
    public Object first() {
        return aggregate.getElement(0);
    }
    @Override
    public boolean isLast() {
        if (index < size){
            return true;
        }else {
            return false;
        }
    }
    @Override
    public void next() {
        if (isLast()) {
            index++;
        }
    }
    @Override
    public Object CurrentElement() {
        return aggregate.getElement(index);
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(6);
        list.add(7);
        list.add(5);
        ConcreteAggregate ca = new ConcreteAggregate(list);
        MyIterator iterator = ca.createIterator();
        while (iterator.isLast()){
            System.out.println(iterator.CurrentElement());
            iterator.next();
        }
    }
}

输出