迭代器模式

当你需要对聚集有多种方式遍历时，可以考虑用迭代器模式。

迭代器模式（Iterator）就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以不暴露集合的内部结构，

又可让外部代码透明的访问集合内部数据

代码示例：

 1 /**
 2  * Iterator:迭代器抽象类
 3  * 用于定义得到开始对象，得到下一对象，判断是否结尾，当前对象
 4  * 等抽象方法的统一接口
 5  */
 6 public abstract class Iterator {
 7     public abstract Object first();
 8     public abstract Object next();
 9     public abstract boolean isDone();
10     public abstract Object currentItem();
11 }

Iterator

 1 public class ConcreteIterator extends Iterator{
 2     private ConcreteAggregate aggregate;  //定义一个具体的聚集对象
 3     private int current = 0;
 4     
 5     /**
 6      * 初始化时将具体聚集对象传入
 7      * @param aggregate
 8      */
 9     public ConcreteIterator(ConcreteAggregate aggregate) {
10         this.aggregate = aggregate;
11     }
12 
13     /**
14      * 得到聚集对象第一个对象
15      */
16     @Override
17     public Object first() {
18         return aggregate.thisObject(0);
19     }
20 
21     @Override
22     public Object next() {
23         Object ret = null;
24         current++;
25         if(current<aggregate.count()){
26             ret = aggregate.thisObject(current);
27         }
28         return ret;
29     }
30 
31     @Override
32     public boolean isDone() {
33         return current>=aggregate.count()?true:false;
34     }
35 
36     @Override
37     public Object currentItem() {
38         // TODO Auto-generated method stub
39         return aggregate.thisObject(current);
40     }
41 
42     public ConcreteAggregate getAggregate() {
43         return aggregate;
44     }
45 
46     public void setAggregate(ConcreteAggregate aggregate) {
47         this.aggregate = aggregate;
48     }
49 
50     public int getCurrent() {
51         return current;
52     }
53 
54     public void setCurrent(int current) {
55         this.current = current;
56     }
57 
58     
59 }

ConcreteIterator

1 /**
2  *Aggregate:聚集抽象类
3  */
4 public abstract class Aggregate {
5     public abstract Iterator createIterator();//创建迭代器
6 }

Aggregate

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 public class ConcreteAggregate extends Aggregate{
 5     //声明一个List变量，用于存放聚合对象
 6     private List<Object> items = new ArrayList<Object>();
 7     @Override
 8     public Iterator createIterator() {
 9         return new ConcreteIterator(this);
10     }
11     
12     /**
13      * 返回聚集总个数
14      */
15     public  int count(){
16         return items.size();
17     }
18     
19     /**
20      * 声明一个搜索器
21      * @param index
22      * @return
23      */
24     public Object thisObject(int index){
25         return items.get(index);
26     }
27     /**
28      * 添加聚合对象
29      */
30     public void add(Object obj){
31         items.add(obj);
32     }
33 
34 }

ConcreteAggregate

 1 public class IteratorTest {
 2 
 3     public static void main(String[] args) {
 4         //聚集对象：-->公交车
 5         ConcreteAggregate agg = new ConcreteAggregate();
 6         agg.add("大鸟");
 7         agg.add("小菜");
 8         agg.add("行李");
 9         agg.add("老外");
10         agg.add("内部员工");
11         agg.add("小偷");
12 
13         Iterator it = new ConcreteIterator(agg);
14         while(!it.isDone()){
15             System.out.println(it.currentItem()+"  请买票");
16             it.next();
17         }
18     }
19 
20 }

test

大鸟  请买票
小菜  请买票
行李  请买票
老外  请买票
内部员工  请买票
小偷  请买票

打印结果