叠代器模式（Iterator），提供一種方法順序訪問一個聚合對象中各個元素，而又不暴露該對象的內部表示。

當需要訪問一個聚集對象，而且不管這些對象是什麽都需要遍歷的時候，就應該考慮用叠代器模式，需要對聚集有多種方式遍歷時，也可以考慮用叠代器模式。為遍歷不同的聚集結構提供如開始、下一個、是否結束、當前哪一項等統一接口。
叠代器模式就是分離了集合對象的遍歷行為，抽象出一個叠代器來負責，這樣既可以做到不暴露集合的內部結構，又可讓外部透明地訪問集合內部的數據。

代碼如下：

 1 /**
 2  * 叠代器抽象類
 3  */
 4 public abstract class Iterator {
 
 5     /**
 6      * 叠代方法：移動到第一個元素
 7      * @return
 8      */
 9     public abstract Object first();
10 
11     /**
12      * 叠代方法：移動到下一個元素
13      * @return
14      */
15     public abstract Object next();
16 
17     /**
18      * 用於定義得到開始對象、得到下一個對象、判斷
19      * 是否到結尾、當前對象等抽象方法，統一接口
20      * 叠代方法：是否為最後一個元素
 
21      * @return
22      */
23     public abstract boolean isDone();
24 
25     /**
26      * 叠代方法：返還當前元素
27      * @return
28      */
29     public abstract Object currentItem();
30 }

 1 /**
 2  * 具體叠代器類繼承叠代器抽象類
 3  */
 4 public class ConcreteIterator extends Iterator {
 5 
 6     /**
 7      * 定義了一個具體聚集對象
 
 8      */
 9     private ConcreteAggregate aggregate;
10     private int current=0;
11 
12     public ConcreteIterator(ConcreteAggregate aggregate) {
13        this.aggregate=aggregate;
14     }
15 
16     /**
17      * 得到聚集的第一個對象
18      * @return
19      */
20     @Override
21     public Object first() {
22         return aggregate.getElement(0);
23     }
24 
25     /**
26      * 得到聚集的下一個對象
27      * @return
28      */
29     @Override
30     public Object next() {
31         Object ret=null;
32         current++;
33         if (current<aggregate.getCount())
34         {
35             ret=aggregate.getCount();
36         }
37         return ret;
38     }
39 
40     /**
41      * 判斷當前是否遍歷到結尾，到結尾返回true
42      * @return
43      */
44     @Override
45     public boolean isDone() {
46         return current>=aggregate.getCount()?true:false;
47     }
48 
49     @Override
50     public Object currentItem() {
51         return aggregate.getElement(current);
52     }
53 }

1 /**
2  * 聚集抽象類
3  */
4 public abstract class Aggregate {
5     public abstract Iterator createIterator();
6 }

 1 /**
 2  * 具體聚集類繼承聚集抽象類
 3  */
 4 public class ConcreteAggregate extends Aggregate {
 5 
 6     /**
 7      * 聲明一個List泛型變量，用於存放聚合對象，用ArrayList同樣可以實現
 8      */
 9     private List<Object> items=new ArrayList<>();
10 
11     public ConcreteAggregate(List<Object> list) {
12         this.items=list;
13     }
14 
15     @Override
16     public Iterator createIterator() {
17         return new ConcreteIterator(this);
18     }
19 
20     /**
21      * 返回聚集總個數
22      * @return
23      */
24     public int getCount() {
25         return items.size();
26     }
27 
28     /**
29      * 取值方法：向外界提供聚集元素
30      */
31     public Object getElement(int index){
32         if (index<getCount()){
33             return items.get(index);
34         }
35         else {
36             return null;
37         }
38     }
39 }

 1 public class Client {
 2     public static void main(String[] args) {
 3 
 4         List<Object> list=new ArrayList<>();
 5         list.add("大鳥");
 6         list.add("小菜");
 7         list.add("行李");
 8         list.add("老外");
 9         list.add("公交內部員工");
10         list.add("小偷");
11 
12         ConcreteAggregate a=new ConcreteAggregate(list);
13         Iterator i=a.createIterator();
14         Object item=i.first();
15         System.out.println("第1："+item.toString());
16         while (!i.isDone()){
17             System.out.println(i.currentItem()+"請買車票");
18             i.next();
19         }
20     }
21 }

一天學習一個設計模式之叠代器模式