设计模式--迭代器模式

设计模式--迭代器模式

一、迭代器模式

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

二、迭代器模式的结构

• 角色

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

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

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

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

• 类图

三、迭代器模式举例

抽象聚合接口：Aggregate.java

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

具体聚合类：ConcreteAggregate.java

 1 package iterator1;
 2 /**
 3  * 具体聚合角色
 4  * @author nick
 5  */
 6 public class ConcreteAggregate implements Aggregate {
 7         
 8         private Object[] objArray = null;       //定义对象数组
 9     
10         public ConcreteAggregate(Object[] objArray){
11             //传入聚合对象的具体内容
12             this.objArray = objArray;
13         }   
14     
15         /**
16          * 实现聚合接口
17          * 调用具体迭代器中的构造方法
18          * 返回具体迭代器迭代器对象
19          */
20         @Override
21         public Iterator createIterator() {
22             return new ConcreteIterator(this);
23         }
24     
25         //获取汇集的大小
26         public int size(){
27             return objArray.length;
28         }
29     
30         // 获取汇集内的元素
31         public Object getElement(int index){     
32             if(index < objArray.length){
33                 return objArray[index];
34             }else{
35                 return null;
36             }
37         }    
38 }

抽象迭代器接口：Iterator.java

 1 package iterator1;
 2 /**
 3  * 抽象迭代器接口
 4  * @author nick
 5  */
 6 public interface Iterator {
 7 ​
 8     void first();           //移动到第一个元素 
 9     void next();            //移动到下一个元素
10     boolean isLast();       //是不是最后一个元素 
11     Object currentItem();   //获取当前元素
12 }

具体迭代器类：ConcreteIterator.java

 1 package iterator1;
 2 /**
 3  * 具体的迭代器
 4  * @author nick
 5  */
 6 public class ConcreteIterator implements Iterator {
 7     private ConcreteAggregate agg;  //持有被迭代的具体的聚合对象
 8     private int index = 0;          //内部索引,记录当前迭代到的索引位置  
 9     private int size = 0;           //记录当前汇集对象的大小  
10     
11     public ConcreteIterator(ConcreteAggregate agg){
12         this.agg = agg;
13         this.size = agg.size();
14         index = 0;
15     } 
16     
17     @Override//移动到第一个元素
18     public void first() {   
19         index = 0;
20     } 
21     
22     @Override//元素后移
23     public void next() {
24         if(index < size)
25         {
26             index ++;
27         }
28     }
29     
30     @Override//判断是否为最后一个元素
31     public boolean isLast() {  
32         return (index >= size)? true :false;
33     }
34     
35     @Override//获取索引处的元素和
36     public Object currentItem() {    
37         return agg.getElement(index);       
38     }
39 }

 

主程序：Application.java

 1 package iterator1;
 2 /**
 3  * 主程序入口
 4  * @author nick
 5  */
 6 public class Application {
 7     public static void main(String[] args) {  
 8          
 9         Object[] objArray = {"One","Two","Three","Four","Five","Six"};     
10          Aggregate agg = new ConcreteAggregate(objArray);//建立聚合对象      
11          //调用聚合对象中实现的建立迭代器的方法建立迭代器
12          Iterator iter = agg.createIterator(); 
13          while(!iter.isLast()){//用迭代器遍历聚合对象中的元素和    
14              System.out.println(iter.currentItem());
15              iter.next();           
16          }
17     }
18 }

运行结果

　　

四、迭代器模式的优缺点

• 优势1：迭代器模式简化了汇集的接口。迭代器具有了一个遍历接口，这样汇集的接口就没必要具有遍历接口。

• 优势2： 因为遍历算法被封装在迭代器角色里面，所以迭代的算法能够独立于汇集角色变化。

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

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