迭代器模式（iterator）:
迭代器模式允许你访问一个数据项序列中的所有元素，而无须关心序列是什么类型（数组、链表、列表或任何其他类型）。它能有效地构建一个数据管道，经过一系列不同的转换或过滤后再从管道的另一端出来。迭代器模式就是提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示。
迭代器模式的角色：
1）抽象迭代器（iterator）：接口声明了遍历集合所需的操作（获取下一个元素、获取当前位置和重新开始迭代等）。
2）具体迭代器（concreteiterator）：实现遍历集合的一种特定算法。迭代器对象必须跟踪自身遍历的进度。这使得多个迭代器可以相互独立地遍历同一个集合。
3）抽象聚合（aggregate）：接口声明一个或多个方法来获取与集合兼容的迭代器。返回方法的类型必须被声明为迭代器接口。
4）具体聚合（concreteaggregate）：会在客户端请求迭代器时返回一个特定的具体迭代器类实体。
5）客户端（client）：通过集合和迭代器的接口与两者进行交互。 这样一来客户端无需与具体类进行耦合， 允许同一客户端代码使用各种不同的集合和迭代器。
示例：
先假设有两家餐厅，主营业务不同，一家是早餐店，一家是晚餐店。
我要评论 1 /// <summary>
2 /// 菜单明细项
3 /// </summary>
4 public class menuitem
5 {
6 private string name;
7 private string description;
8 private bool vegetarin;
9 private double price;
10
11 public menuitem(string name, string description, bool vegetarin, double price)
12 {
13 this.name = name;
14 this.description = description;
15 this.vegetarin = vegetarin;
16 this.price = price;
17 }
18
19 public string getname()
20 {
21 return this.name;
22 }
23
24 public double getprice()
25 {
26 return price;
27 }
28
29 public bool isvegetarian()
30 {
31 return vegetarin;
32 }
33
34 public string getdescription()
35 {
36 return description;
37 }
38 }
39
40 /// <summary>
41 /// 早餐菜单
42 /// </summary>
43 public class breakfastmenu
44 {
45 private list<menuitem> menuitems;
46
47 public breakfastmenu()
48 {
49 menuitems = new list<menuitem>();
50 additem("牛奶", "牛奶description", false, 3.0);
51 additem("油条", "油条description", false, 1.0);
52 additem("馒头", "馒头description", true, 1.0);
53 additem("豆浆", "doujiangdescription", true, 1.5);
54 }
55
56 public void additem(string name, string description, bool vegetarian, double price)
57 {
58 menuitem menuitem = new menuitem(name, description, vegetarian, price);
59 menuitems.add(menuitem);
60 }
61
62 public list<menuitem> getmenuitems()
63 {
64 return menuitems;
65 }
66 }
67
68 /// <summary>
69 /// 晚餐菜单
70 /// </summary>
71 public class dinnermenu
72 {
73 private static readonly int max_items = 6;
74 private int numberofitems = 0;
75 private menuitem[] menuitems;
76
77 public dinnermenu()
78 {
79 menuitems = new menuitem[max_items];
80 additem("香菇豆腐饭", "香菇豆腐", false, 10.5);
81 additem("蛋炒饭", "哈哈", false, 8.5);
82 additem("鱼香肉丝", "你猜", true, 15.5);
83 }
84
85 public void additem(string name, string description, bool vegetarian, double price)
86 {
87 menuitem menuitem = new menuitem(name, description, vegetarian, price);
88 if (numberofitems > max_items)
89 {
90 console.writeline("菜单已满");
91 }
92 else
93 {
94 menuitems[numberofitems] = menuitem;
95 numberofitems++;
96 }
97 }
98
99 public menuitem[] getmenuitems()
100 {
101 return menuitems;
102 }
103 }
现在两家合并了，服务员那菜单的时候就要拿两份菜单。
1 public static void main(string[] args)
2 {
3 breakfastmenu breakfastmenu = new breakfastmenu();
4 list<menuitem> breakfastitems = breakfastmenu.getmenuitems();
5
6 dinnermenu dinermenu = new dinnermenu();
7 menuitem[] lunchitems = dinermenu.getmenuitems();
8
9 for (int i = 0; i < breakfastitems.count; i++)
10 {
11 menuitem menuitem = breakfastitems[i] as menuitem;
12 console.writeline(menuitem.getname() + " " + menuitem.getprice().tostring() + " " + menuitem.getdescription().tostring());
13 }
14
15 for (int j = 0; j < lunchitems.length; j++)
16 {
17 menuitem lunchitem = lunchitems[j];
18 if (lunchitem != null)
19 {
20 console.writeline(lunchitem.getname() + " " + lunchitem.getprice().tostring() + " " + lunchitem.getdescription().tostring());
21 }
22 }
23 }
我们发现，由于两份菜单数据结构的不同，我们不得不重写多余的代码，显得很臃肿。我们会想：能不能有一个东西能够让我们不需要知道菜单的数据结构，直接就可以获取其内部元素呢？答案是肯定的，这就是我们本节所说的迭代器模式。
先定义一个接口迭代器并实现晚餐菜单迭代器和晚餐菜单迭代器。
1 /// <summary>
2 /// 接口迭代器
3 /// </summary>
4 public interface iterator
5 {
6 /// <summary>
7 /// 用来判断下一个元素是否为空
8 /// </summary>
9 /// <returns></returns>
10 bool hasnext();
11
12 /// <summary>
13 /// 用来获取当前元素
14 /// </summary>
15 /// <returns></returns>
16 object next();
17 }
18
19 /// <summary>
20 /// 早餐菜单迭代器
21 /// </summary>
22 public class breakfastiterator : iterator
23 {
24 private list<menuitem> items;
25 private int position = 0;
26
27 public breakfastiterator(list<menuitem> items)
28 {
29 this.items = items;
30 }
31
32 public bool hasnext()
33 {
34 return position <= items.count - 1 && items[position] != null;
35 }
36
37 public object next()
38 {
39 menuitem item = items[position];
40 position++;
41 return item;
42 }
43 }
44
45 /// <summary>
46 /// 晚餐菜单迭代器
47 /// </summary>
48 public class dinneriterator : iterator
49 {
50 private menuitem[] items;
51 private int position = 0;
52
53 public dinneriterator(menuitem[] items)
54 {
55 this.items = items;
56 }
57
58 public bool hasnext()
59 {
60 return position <= items.length && items[position] != null;
61 }
62
63 public object next()
64 {
65 menuitem item = items[position];
66 position++;
67 return item;
68 }
69 }
修改菜单。
1 /// <summary>
2 /// 抽象聚合对象，用于创建一个迭代器对象
3 /// </summary>
4 public interface imenu
5 {
6 iterator createiterator();
7 }
8
9 /// <summary>
10 /// 早餐菜单
11 /// </summary>
12 public class breakfastmenu : imenu
13
14 {
15 private list<menuitem> menuitems;
16
17 public breakfastmenu()
18 {
19 menuitems = new list<menuitem>();
20 additem("牛奶", "牛奶description", false, 3.0);
21 additem("油条", "油条description", false, 1.0);
22 additem("馒头", "馒头description", true, 1.0);
23 additem("豆浆", "doujiangdescription", true, 1.5);
24 }
25
26 public void additem(string name, string description, bool vegetarian, double price)
27 {
28 menuitem menuitem = new menuitem(name, description, vegetarian, price);
29 menuitems.add(menuitem);
30 }
31
32 //public list<menuitem> getmenuitems()
33 //{
34 // return menuitems;
35 //}
36
37 public iterator createiterator()
38 {
39 return new breakfastiterator(menuitems);
40 }
41 }
42
43 /// <summary>
44 /// 晚餐菜单
45 /// </summary>
46 public class dinnermenu : imenu
47
48 {
49 private static readonly int max_items = 6;
50 private int numberofitems = 0;
51 private menuitem[] menuitems;
52
53 public dinnermenu()
54 {
55 menuitems = new menuitem[max_items];
56 additem("香菇豆腐饭", "香菇豆腐", false, 10.5);
57 additem("蛋炒饭", "哈哈", false, 8.5);
58 additem("鱼香肉丝", "你猜", true, 15.5);
59 }
60
61 public void additem(string name, string description, bool vegetarian, double price)
62 {
63 menuitem menuitem = new menuitem(name, description, vegetarian, price);
64 if (numberofitems > max_items)
65 {
66 console.writeline("菜单已满");
67 }
68 else
69 {
70 menuitems[numberofitems] = menuitem;
71 numberofitems++;
72 }
73 }
74
75 //public menuitem[] getmenuitems()
76 //{
77 // return menuitems;
78 //}
79
80 public iterator createiterator()
81 {
82 return new dinneriterator(menuitems);
83 }
84 }
这个时候，两份餐单的输出是这样的。
1 public static void main(string[] args)
2 {
3 imenu breakfastmenu = new breakfastmenu();
4 imenu dinnermenu = new dinnermenu();
5 breakfastmenu.createiterator();
6 iterator dinneriterator = dinnermenu.createiterator();
7 iterator breakfastiterator = breakfastmenu.createiterator();
8
9 print(breakfastiterator);
10 print(dinneriterator);
11
12 static void print(iterator iterator)
13 {
14 while (iterator.hasnext())
15 {
16 menuitem menuitem = (menuitem)iterator.next();
17 console.writeline(menuitem.getname() + " " + menuitem.getprice().tostring() + " " + menuitem.getdescription().tostring());
18 }
19 }
20 }
迭代器模式适用性：
1）当集合背后为复杂的数据结构，且你希望对客户端隐藏其复杂性时（出于使用便利性或安全性的考虑），可以使用迭代器。
2）可以减少程序中重复的遍历代码。
3）如果你希望代码能够遍历不同的甚至是无法预知的数据结构，可以使用迭代器。
迭代器模式的优缺点：
优点：
1）它支持以不同的方式遍历一个聚合对象。
2）迭代器简化了聚合类。
3）在同一个聚合上可以有多个遍历。
4）在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。符合ocp原则。
缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
参考：
如对本文有疑问， 点击进行留言回复！！
荐 厉害了！阿里P8架构师用4大技术文档带你深入解读爆火的中台战略
FlowableException: Error initialising dmn data model报错问题
网友评论