设计模式之迭代器模式

迭代器模式(Iterator)，其含义是提供一种方法顺序访问一个聚合对象中的各个元素，而又不需暴露该对象的内部表示。这一模式的关键思想是将对列表的访问和遍历从列表对象中分离出来并放入一个迭代器对象中。迭代器类定义了一个访问该列表元素的接口。能够理解为咱们常见的java集合中的Iterator接口，很是相似。

其适用性：

访问一个聚合对象的内容而无需暴露它的内部表示，

支持对聚合对象的多种遍历，

为遍历不一样的聚合结构提供一个统一的接口(即，支持多态迭代)。 

其结构图：

                             

迭代器和列表式耦合在一块儿的，并且客户对象必须知道遍历的是一个列表而不是其余聚合结构，咱们在使用时其实有两个迭代器，一个是外部迭代器，另外一个是内部迭代器，外部迭代器是由客户端主动推动遍历的步伐，显示地向迭代器请求下一个元素，而内部迭代器客户只需向其提交一个代执行的操做，而迭代器将对聚合中的每个元素实施该操做。

在实现时， Iterator类有一个属性是Aggregate的实例，该方式是对象适配器的运用，Iterator的相关操做都是底层经过Aggregate的实例来实现的。如：

package  org.designpattern.behavioral.iterator;
public  abstract  class Iterator {
     protected Aggregate aggregate;
     protected  int index;

     public Aggregate getAggregate() {
         return aggregate;
    }

     public  void setAggregate(Aggregate aggregate) {
         this.aggregate = aggregate;
    }
     public  abstract  void first();
     public  abstract  void next();
     public  abstract  void last();
     public  abstract  boolean isDone();
     public  abstract Object currentItem();
}

  Aggregate定义接口操做(在此略去)，由本身的实现类实现：

package  org.designpattern.behavioral.iterator;
import java.util.ArrayList;

public  class ConcreteAggregate  extends Aggregate{
     private  Object[] objs;
     public ConcreteAggregate(){
         this.objs =  new Object[32];
         this.size = 0;
    }
    @Override
     public Iterator createIterator() {
        Iterator iterator =  new ConcreteIterator();
        iterator.setAggregate( this);
         return iterator;   // To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
     public Object getItem( int index) {
         return  this.objs[index];   // To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
     public  int getSize() {
         return  this.size ;   // To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
     public  void addObject(Object obj) {
         this.objs[ this.size] = obj;
         this.size++;
         // To change body of implemented methods use File | Settings | File Templates.
    }
}

  Iterator的子类操做均是经过Aggregate的实现类来实现：

package  org.designpattern.behavioral.iterator;
public  class ConcreteIterator  extends Iterator {
     public ConcreteIterator(){
         this.index = 0;
    }

    @Override
     public Object currentItem() {
         return  this.getAggregate().getItem( this.index);   // To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
     public  void first() {
         this.index = 0;
         // To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
     public  void next() {
         if( this.index <  this.getAggregate().getSize()){
             this.index ++;
        }
         // To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
     public  void last() {
         this.getAggregate().getSize();
         // To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
     public  boolean isDone() {
         return  this.index ==  this.getAggregate().getSize();   // To change body of implemented methods use File | Settings | File Templates.
    }

} 

 客户端测试类就能够直接像使用普通的迭代器同样使用了。由此看迭代器将具体的集合类和迭代类分离开来，使用迭代器和具体集合类的复用性更佳，且外界代码使用时能够使用迭代器遍历集合，从而无需关心集合的内部细节。