设计模式--迭代器模式

设计模式--迭代器模式

1、迭代器模式

　　迭代器模式：又称为游标（cursor）模式，也就是抽象一个迭代器类来分离聚集的遍历行为，这样既可以做到不暴露聚集的内部结构，又可让外部代码透明地访问聚集内部的数据。

2、迭代器模式的结构

• 角色

  抽象聚合角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口；

  具体聚合角色：实现抽象聚合类，返回一个具体迭代器的实例；

  抽象迭代器角色：定义访问和遍历聚合元素的接口，通常包含first()、next() 等方法；

  具体迭代器角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

• 类图

  

3、迭代器模式举例

抽象聚合接口：Aggregate.java

package iterator;
/**
 * 抽象聚合接口
 * @author nick
 *
 */
public interface Aggregate {            
    public abstract Iterator createIterator();  //定义抽象方法，返回迭代器类对象
}

具体聚合类：ConcreteAggregate.java

package iterator1;
/**
 * 具体聚合角色
 * @author nick
 */
public class ConcreteAggregate implements Aggregate {
        
        private Object[] objArray = null;       //定义对象数组
    
        public ConcreteAggregate(Object[] objArray){
            //传入聚合对象的具体内容
            this.objArray = objArray;
        }   
    
        /**
         * 实现聚合接口
         * 调用具体迭代器中的构造方法
         * 返回具体迭代器迭代器对象
         */
        @Override
        public Iterator createIterator() {
            return new ConcreteIterator(this);
        }
    
        //获取聚集的大小
        public int size(){
            return objArray.length;
        }
    
        // 获取聚集内的元素
        public Object getElement(int index){     
            if(index < objArray.length){
                return objArray[index];
            }else{
                return null;
            }
        }    
}

抽象迭代器接口：Iterator.java

package iterator1;
/**
 * 抽象迭代器接口
 * @author nick
 */
public interface Iterator {
​
    void first();           //移动到第一个元素 
    void next();            //移动到下一个元素
    boolean isLast();       //是否是最后一个元素 
    Object currentItem();   //获取当前元素
}

具体迭代器类：ConcreteIterator.java

package iterator1;
/**
 * 具体的迭代器
 * @author nick
 */
public class ConcreteIterator implements Iterator {
    private ConcreteAggregate agg;  //持有被迭代的具体的聚合对象
    private int index = 0;          //内部索引,记录当前迭代到的索引位置  
    private int size = 0;           //记录当前聚集对象的大小  
    
    public ConcreteIterator(ConcreteAggregate agg){
        this.agg = agg;
        this.size = agg.size();
        index = 0;
    } 
    
    @Override//移动到第一个元素
    public void first() {   
        index = 0;
    } 
    
    @Override//元素后移
    public void next() {
        if(index < size)
        {
            index ++;
        }
    }
    
    @Override//判断是否为最后一个元素
    public boolean isLast() {  
        return (index >= size)? true :false;
    }
    
    @Override//获取索引处的元素和
    public Object currentItem() {    
        return agg.getElement(index);       
    }
}

主程序：Application.java

package iterator1;
/**
 * 主程序入口
 * @author nick
 */
public class Application {
    public static void main(String[] args) {  
         
        Object[] objArray = {"One","Two","Three","Four","Five","Six"};     
         Aggregate agg = new ConcreteAggregate(objArray);//创建聚合对象      
         //调用聚合对象中实现的创建迭代器的方法创建迭代器
         Iterator iter = agg.createIterator(); 
         while(!iter.isLast()){//用迭代器遍历聚合对象中的元素和    
             System.out.println(iter.currentItem());
             iter.next();           
         }
    }
}

运行结果

　　

4、迭代器模式的优缺点

• 优点1：迭代器模式简化了聚集的接口。迭代器具备了一个遍历接口，这样聚集的接口就不必具备遍历接口。

• 优点2： 由于遍历算法被封装在迭代器角色里面，因此迭代的算法可以独立于聚集角色变化。

• 优点3：在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

• 缺点1：迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。