设计模式初探-迭代器模式

迭代器模式(ITERATOR)，又称游标(Cursor)，提供了一种方法，用于顺序访问一个聚合对象中的各个元素，而不需暴露该对象的内部表示，属于对象行为型模式。迭代器模式通过将对聚合对象(通常为列表)的访问和遍历从聚合对象中分离出来并放入一个迭代器对象中，迭代器对象知道如何遍历列表，这样不仅可以简化聚合对象的实现(将遍历操作交给迭代器负责，自己只负责保存)，还可以以不同的方式遍历列表。

一、使用场景

1、访问一个聚合对象的内容而无需暴露它的内部表示。

2、支持对聚合对象的多种遍历，比如正向遍历，逆向遍历，JDK的迭代器只实现正向遍历。

3、为遍历不同的聚合结构提供一个统一的接口。对不同的聚合结构只需切换要遍历的对象而不需改变遍历过程的代码。

二、UML图

三、Java实现

[java] view plain copy

1. package study.patterns.iterator;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. /** 
6.  * 迭代器模式，为遍历聚合结构而生!  
7.  * 迭代器模式通常使用工厂方法模式来实例化适当的迭代器子类。 
8.  * @author qbg 
9.  */  
10. public class IteratorPattern {  
11.     public static void main(String[] args) {  
12.         List<String> list = new ArrayList<String>();  
13.         list.add("Java编程思想");  
14.         list.add("设计模式");  
15.         list.add("编程匠艺");  
16.         list.add("重构");  
17.         AbstractList<String> books = new ConcreteList<String>(list);  
18.         Iterator<String> iterator = books.iterator();  
19.         System.out.println("=======正向遍历===========");  
20.         while(iterator.hasNext()){  
21.             System.out.print(iterator.next()+"，");  
22.         }  
23.         System.out.println("\n=======逆向遍历===========");  
24.         while(iterator.hasPrevious()){  
25.             System.out.print(iterator.previous()+"，");  
26.         }  
27.     }  
28. }  
29. /** 
30.  * 抽象聚合类 
31.  * @param <E> 
32.  */  
33. abstract class AbstractList<E>{  
34.     protected List<E> elements = new ArrayList<E>();  
35.       
36.     public AbstractList(List<E> eles){  
37.         this.elements = eles;  
38.     }  
39.       
40.     public void add(E e){  
41.         elements.add(e);  
42.     }  
43.       
44.     public void remove(E e){  
45.         elements.remove(e);  
46.     }  
47.       
48.     public List<E> getAll(){  
49.         return elements;  
50.     }  
51.       
52.     /** 
53.      * 声明创建迭代器对象的抽象工厂方法 
54.      */  
55.     public abstract Iterator<E> iterator();  
56. }  
57. /** 
58.  * 具体聚合类，创建基于该聚合类的迭代器 
59.  * @param <E> 
60.  */  
61. class ConcreteList<E> extends AbstractList<E>{  
62.   
63.     public ConcreteList(List<E> eles) {  
64.         super(eles);  
65.     }  
66.   
67.     @Override  
68.     public Iterator<E> iterator() {  
69.         return new ConcreteIterator<E>(this);  
70.     }  
71. }  
72. /** 
73.  * 遍历器抽象接口，支持泛型 
74.  */  
75. interface Iterator<E>{  
76.     /** 
77.      * 正向遍历，判断是否有后继节点 
78.      */  
79.     public boolean hasNext();  
80.     /** 
81.      * 游标下移，返回游标越过的元素引用  
82.      */  
83.     public E next();  
84.     /** 
85.      * 逆向遍历，判断是否有前驱节点  
86.      */  
87.     public boolean hasPrevious();  
88.     /** 
89.      * 游标上移，返回游标越过的元素引用 
90.      */  
91.     public E previous();  
92. }  
93. /** 
94.  *  具体迭代器，用于遍历AbstractList<E>集合. 
95.  *  支持正向遍历和逆向遍历  
96.  * @param <E> 
97.  */  
98. class ConcreteIterator<E> implements Iterator<E>{  
99.     private AbstractList<E> list;//要遍历的集合  
100.     private List<E> elements;//集合中的元素  
101.     private int cursor_forword;//正向遍历的游标，用于记录正向遍历的位置  
102.     private int cursor_backword;//逆向遍历的游标，用于记录逆向遍历的位置  
103.       
104.     public ConcreteIterator(AbstractList<E> list){  
105.         this.list = list;  
106.         this.elements = this.list.getAll();//获取集合元素  
107.         this.cursor_forword = 0;//设置正向遍历游标初始值  
108.         this.cursor_backword = elements.size()-1;//设置逆向遍历游标初始值  
109.     }  
110.       
111.     @Override  
112.     public boolean hasNext() {  
113.         return cursor_forword < elements.size();  
114.     }  
115.   
116.     @Override  
117.     public E next() {  
118.         E e = elements.get(cursor_forword);  
119.         cursor_forword++;  
120.         return e;  
121.     }  
122.   
123.     @Override  
124.     public boolean hasPrevious() {  
125.         return cursor_backword >= 0;  
126.     }  
127.   
128.     @Override  
129.     public E previous() {  
130.         E e = elements.get(cursor_backword);  
131.         cursor_backword--;  
132.         return e;  
133.     }  
134.   
135. }  

运行结果：

[plain] view plain copy

1. =======正向遍历===========  
2. Java编程思想，设计模式，编程匠艺，重构，  
3. =======逆向遍历===========  
4. 重构，编程匠艺，设计模式，Java编程思想，  

四、模式优缺点

优点：

1、支持以不同的方式遍历一个聚合。想改变遍历方式只需用一个不同的迭代器实例代替原先的实例即可。

2、迭代器简化聚合的接口。有了迭代器的遍历接口，聚合本身就不需要类似的遍历接口了。

3、在同一个聚合上可以有多个遍历。每个迭代器保持它自己的遍历状态，互不影响。

缺点：

1、抽象迭代器的设计比较难以把握，如果前期设计不好，后期改动就会非常大。比如JDK的迭代器只支持正向遍历，如果想实现其他遍历方式只能通过添加辅助类实现。