在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。
既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：
- 暴露了聚合类的内部表示，使其数据不安全。
- 增加了客户的负担。
“迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”。
迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
迭代器模式是一种对象行为型模式，其主要优点如下：
- 访问一个聚合对象的内容而无须暴露它的内部表示。
- 遍历任务交由迭代器完成，这简化了聚合类。
- 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
- 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
- 封装性良好，为遍历不同的聚合结构提供一个统一的接口。
其主要缺点是：增加了类的个数，这在一定程度上增加了系统的复杂性。
迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。
模式的结构#
迭代器模式主要包含以下角色：
- 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
- 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
- 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 HasNext()、First()、Next() 等方法。
- 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
其结构图如图所示：
模式的实现#
迭代器模式的实现代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
| class Program
{
static void Main(string[] args)
{
IAggregate ag = new ConcreteAggregate();
ag.Add("中山大学");
ag.Add("华南理工");
ag.Add("韶关学院");
Console.WriteLine("聚合的内容有：");
IIterator it = ag.GetIterator();
while (it.HasNext())
{
Object ob = it.Next();
Console.WriteLine(ob.ToString());
}
Console.WriteLine("First：" + it.First().ToString());
Console.Read();
}
}
public interface IAggregate
{
void Add(Object obj);
void Remove(Object obj);
IIterator GetIterator();
}
public class ConcreteAggregate : IAggregate
{
private List<Object> list=new List<Object>();
public void Add(Object obj)
{
list.Add(obj);
}
public void Remove(Object obj)
{
list.Remove(obj);
}
public IIterator GetIterator()
{
return(new ConcreteIterator(list));
}
}
public interface IIterator
{
Object First();
Object Next();
bool HasNext();
}
public class ConcreteIterator : IIterator
{
private List<Object> list=null;
private int index=-1;
public ConcreteIterator(List<Object> list)
{
this.list=list;
}
public bool HasNext()
{
if(index<list.Count-1)
{
return true;
}
else
{
return false;
}
}
public Object First()
{
index=0;
Object obj=list[index];;
return obj;
}
public Object Next()
{
Object obj=null;
if(this.HasNext())
{
obj=list[++index];
}
return obj;
}
}
|
程序运行结果如下：
1
2
3
4
5
| 聚合的内容有：
中山大学
华南理工
韶关学院
First：中山大学
|
注：在C#中，推荐使用泛型代替Object以降低性能消耗。
前面介绍了关于迭代器模式的结构与特点，下面介绍其应用场景，迭代器模式通常在以下几种情况使用：
- 当需要为聚合对象提供多种遍历方式时。
- 当需要为遍历不同的聚合结构提供一个统一的接口时。
- 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。
由于聚合与迭代器的关系非常密切，所以大多数语言在实现聚合类时都提供了迭代器类，因此大数情况下使用语言中已有的聚合类的迭代器就已经够了。
迭代器模式常常与组合模式结合起来使用，在对组合模式中的容器构件进行访问时，经常将迭代器潜藏在组合模式的容器构成类中。当然，也可以构造一个外部迭代器来对容器构件进行访问，其结构图如图所示：
