GOF23设计模式之迭代器模式（iterator）

 1 /**
 2  * 自定义迭代器接口
 3  * @author CL
 4  *
 5  */
 6 public interface MyIterator {
 7     /**
 8      * 如果仍有元素可以迭代，则返回 true
 9      * @return
10      */
11     boolean hasNext();
12     /**
13      * 返回迭代的下一个元素
14      * @return
15      */
16     Object next();
17     /**
18      * 从迭代器指向的集合中移除迭代器返回的最后一个元素
19      */
20     void remove();
21     
22 }

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 /**
 5  * 自定义聚合类
 6  * @author CL
 7  *
 8  */
 9 public class ConcreteAggregate {
10     private List<Object> list;
11 
12     public ConcreteAggregate() {
13         list = new ArrayList<Object>();
14     }
15     
16     public boolean addObject(Object obj) {
17         return this.list.add(obj);
18     }
19     
20     public boolean removeObject(Object obj) {
21         return this.list.remove(obj);
22     }
23     
24     /**
25      * 获得正向遍历的迭代器对象
26      * @return
27      */
28     public MyIterator creatIterator() {
29         return new ConcreteIterator(0);
30     }
31     
32     /**
33      * 获得逆向遍历的迭代器对象
34      * @return
35      */
36     public MyIterator creatConverseIterator() {
37         return new ConcreteIterator(list.size()-1);
38     }
39     
40     /**
41      * 自定义迭代器内部类
42      * @author CL
43      *
44      */
45     private class ConcreteIterator implements MyIterator {
46         
47         private int cursor;
48         
49         private final int firstValue;
50         
51         public ConcreteIterator(int cursor) {
52             this.cursor = cursor;
53             this.firstValue = cursor;
54         }
55 
56         @Override
57         public boolean hasNext() {
58             if (firstValue == 0) {    //正向遍历
59                 if (cursor < list.size()) {
60                     return true;
61                 }
62             } else if (firstValue == list.size()-1) {    //逆向遍历
63                 if (cursor >= 0) {
64                     return true;
65                 }
66             }
67             return false;
68         }
69 
70         @Override
71         public Object next() {
72             if (firstValue == 0) {    //正向遍历
73                 if (cursor < list.size()) {
74                     return list.get(cursor++);
75                 }
76             } else if (firstValue == list.size()-1) {    //逆向遍历
77                 if (cursor >= 0) {
78                     return list.get(cursor--);
79                 }
80             }
81             return null;
82         }
83 
84         @Override
85         public void remove() {
86             list.remove(cursor);
87         }
88     }
89 }

 1 /**
 2  * 测试迭代器对象
 3  * @author CL
 4  *
 5  */
 6 public class Client {
 7 
 8     public static void main(String[] args) {
 9         ConcreteAggregate ca = new ConcreteAggregate();
10         ca.addObject("aa");
11         ca.addObject("bb");
12         ca.addObject("cc");
13         ca.addObject("dd");
14         
15         System.out.println("正向遍历：");
16         MyIterator it = ca.creatIterator();
17         while (it.hasNext()) {
18             System.out.println(it.next());
19         }
20         
21         System.out.println("逆向遍历：");
22         MyIterator it2 = ca.creatConverseIterator();
23         while (it2.hasNext()) {
24             System.out.println(it2.next());
25         }
26     }
27 }

正向遍历：
aa
bb
cc
dd
逆向遍历：
dd
cc
bb
aa