迭代器模式（Iterator）

1. 作用

迭代器模式又叫游标(Cursor)模式，是对象的行为模式。迭代子模式可以顺序地访问一个聚集中的元素而不必暴露聚集的内部表象。

2. 聚集和JAVA聚集

多个对象聚在一起形成的总体称之为聚集(Aggregate)，聚集对象是能够包容一组对象的容器对象。聚集依赖于聚集结构的抽象化，具有复杂化和多样性。数组就是最基本的聚集，也是其他的JAVA聚集对象的设计基础。

JAVA聚集对象是实现了共同的java.util.Collection接口的对象，是JAVA语言对聚集概念的直接支持。从1.2版开始，JAVA语言提供了很多种聚集，包括Vector、ArrayList、HashSet、HashMap、Hashtable等，这些都是JAVA聚集的例子。

3. 分类

• 白箱聚集与外禀迭代器
• 黑箱聚集于内禀迭代器

4. 白箱聚集与外禀迭代器

由于聚集自己实现迭代逻辑，并向外部提供适当的接口，使得迭代子可以从外部控制聚集元素的迭代过程。这样一来迭代子所控制的仅仅是一个游标而已，这种迭代子叫做游标迭代子（Cursor Iterator）。由于迭代子是在聚集结构之外的，因此这样的迭代子又叫做外禀迭代子（Extrinsic Iterator）

白箱聚集与外禀迭代器

抽象聚集角色

public abstract class Aggregate {
    public abstract Iterator createIterator();
}

具体聚集角色

public class ConcreteAggregate extends Aggregate{
    
    public Integer[] arr;
    
    public ConcreteAggregate(Integer[] arr) {
        this.arr = arr;
    }
    
    @Override
    public Iterator createIterator() {
        // TODO Auto-generated method stub
        return new ConcreteIterator(this);
    }
    
    public Integer currentItem(int i) {
        if(i

抽象迭代器角色

public abstract class Iterator {
    public abstract void first();
    public abstract void next();
    public abstract int getItem();
    public abstract boolean isDone(); 
    
}

具体迭代器角色

public class ConcreteIterator extends Iterator{
    private int index;
    private ConcreteAggregate agg;
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.agg = aggregate;
        index = 0;
    }

    @Override
    public void first() {
        index = 0;
    }
    
    @Override
    public void next() {
        if(index < agg.size()) {
            index++;    
        }
    }
    
    @Override
    public int getItem() {
        return agg.currentItem(index);
    }
    
    @Override
    public boolean isDone() {
        return index >= agg.size();
    }
    
    
}

具体使用

public class WhiteBoxIteratorPatternMain {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer[] array = {1,2,3,4,5};
        ConcreteAggregate aggregate = new ConcreteAggregate(array);
        Iterator iterator = aggregate.createIterator();
        while(!iterator.isDone()) {
            System.out.println(iterator.getItem());
            iterator.next();
        }
    }

}

5. 黑箱聚集于内禀迭代器

由于迭代子是聚集的内部类，迭代子可以自由访问聚集的元素，所以迭代子可以自行实现迭代功能并控制对聚集元素的迭代逻辑。由于迭代子是在聚集的结构之内定义的，因此这样的迭代子又叫做内禀迭代子（Intrinsic Iterator）。

为了说明黑箱方案的细节，这里给出一个示意性的黑箱实现。在这个实现里，聚集类ConcreteAggregate含有一个内部成员类ConcreteIterator，也就是实现了抽象迭代子接口的具体迭代子类，同时聚集并不向外界提供访问自己内部元素的方法。

黑箱聚集于内禀迭代器

抽象聚集角色

public abstract class Aggregate {
    public abstract Iterator createIterator();
}

抽象迭代器角色

public abstract class Iterator {
    public abstract void first();
    public abstract void next();
    public abstract boolean isDone();
    public abstract int getItem();
}

具体聚集角色
实现了抽象聚集角色所要求的接口，也就是createIterator()方法。此外，聚集类有一个内部成员类ConcreteIterator，这个内部类实现了抽象迭代子角色所规定的接口；而工厂方法createIterator()所返还的就是这个内部成员类的实例。

public class ConcreteAggregate extends Aggregate{
    public Integer[] arr = null;
    
    public ConcreteAggregate(Integer[] arr) {
        this.arr = arr;
    }
    
    @Override
    public Iterator createIterator() {
        // TODO Auto-generated method stub
        return new ConcreteItertor();
    }
    
    
    public class ConcreteItertor extends Iterator{
        private int index;
        
        public ConcreteItertor() {
            index = 0;
        }
        
        @Override
        public void first() {
            index = 0;
        }
        
        @Override
        public void next() {
            if(index < arr.length) {
                index++;
            }
        }
        
        @Override
        public int getItem() {
            return arr[index];
        }
        
        @Override
        public boolean isDone() {
            return index >= arr.length;
        }
        
    }
    
}

具体实现

public class BlackBoxIteratorPatternMain {

    public static void main(String[] args) {
        
        Integer[] array = {1,2,3,4,5};
        ConcreteAggregate aggregate = new ConcreteAggregate(array);
        Iterator iterator = aggregate.createIterator();
        for(iterator.first();!iterator.isDone();iterator.next()) {
            System.out.println(iterator.getItem());
        }

    }

}

6. 迭代器模式的优点

• 迭代子模式简化了聚集的接口。迭代子具备了一个遍历接口，这样聚集的接口就不必具备遍历接口。
• 每一个聚集对象都可以有一个或多个迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。因此，一个聚集对象可以同时有几个迭代在进行之中。
• 由于遍历算法被封装在迭代子角色里面，因此迭代的算法可以独立于聚集角色变化。