一天学习一个设计模式之迭代器模式

迭代器模式（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 }

原文地址：https://www.cnblogs.com/gousheng107/p/8177445.html