迭代器模式

迭代器模式

案例引入

需求

编写需求展示一个学校院系结构，需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，且多个学院，存储系的数据机构不同，有的是集合，有的是数组。
传统解决方式

让系继承学院，学院继承学校。
传统解决方式问题分析

• 1.将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。
  
• 2.实际上我们的要求是，在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好的实现遍历操作。
  
• 3.解决方案 => 迭代器模式
  

基本介绍

• 1.迭代器模式(Iterator Pattern)是常用的设计模式，属于行为模式。
  
• 2.如果我们的集合元素使用不同的方式实现的，有数组，还有java的集合类，或者还有其他的方式，当客户端要遍历这些元素的时候，就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。
  
• 3.迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法，遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部结构。
  

原理类图


原理图说明

1.Iterator迭代器接口，是系统提供的，含有hashNext()，next()，remove()等方法。
2.ConcreteIterator具体的迭代器模式，管理迭代。
3.Aggregate一个统一的聚合接口，将客户端和具体聚合解耦。
4.ConcreteAggregate具体的聚合持有对象类，并提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合。
5.Client 客户端，迭代器模式使用者。
使用迭代器模式完成案例

实现类图


代码实现

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 学院接口
5. */
6. public interface College {
8.     public String getName();
10.     public Iterator createIterator();
12.     public void addDepartment(String name,String desc);
14. }
15. /**
16. * @author 长名06
17. * @version 1.0
18. */
19. public class ComputerCollege implements College{
21.     Department[] departments;
22.     int numOfDepartment = 0;
24.     public ComputerCollege(){
25.         departments = new Department[5];
26.         addDepartment("java专业","java语言第一");
27.         addDepartment("php专业","php语言第一");
28.         addDepartment("c++专业","c++语言第一");
29.     }
31.     @Override
32.     public String getName() {
33.         return "计算机学院";
34.     }
36.     @Override
37.     public Iterator createIterator() {
38.         return new ComputerCollegeIterator(departments);
39.     }
41.     @Override
42.     public void addDepartment(String name, String desc) {
43.         departments[numOfDepartment] = new Department(name,desc);
44.         numOfDepartment ++;
45.     }
46. }
47. /**
48. * @author 长名06
49. * @version 1.0
50. */
51. public class InfoCollege implements College{
53.     private List<Department> departmentList ;
55.     public InfoCollege() {
56.         departmentList = new ArrayList<Department>();
57.         addDepartment("物联网工程","第一");
58.         addDepartment("电子信息工程","第一");
59.         addDepartment("通信工程","第一");
60.     }
62.     @Override
63.     public String getName() {
64.         return "信息工程学院";
65.     }
67.     @Override
68.     public Iterator createIterator() {
69.         return new InfoCollegeIterator(departmentList);
70.     }
72.     @Override
73.     public void addDepartment(String name, String desc) {
74.         Department department = new Department(name, desc);
75.         departmentList.add(department);
76.     }
77. }
78. /**
79. * @author 长名06
80. * @version 1.0
81. * 系
82. */
83. public class Department {
85.     private String name;
87.     private String desc;//描述
89.     public Department(String name, String desc) {
90.         this.name = name;
91.         this.desc = desc;
92.     }
94.     public String getName() {
95.         return name;
96.     }
98.     public void setName(String name) {
99.         this.name = name;
100.     }
102.     public String getDesc() {
103.         return desc;
104.     }
106.     public void setDesc(String desc) {
107.         this.desc = desc;
108.     }
109. }
110. /**
111. * @author 长名06
112. * @version 1.0
113. */
114. public class ComputerCollegeIterator implements Iterator {
116.     //计算机学院使用数组存放系
117.     private Department[] departments;
118.     private int index = 0;
120.     public ComputerCollegeIterator(Department[] departments) {
121.         this.departments = departments;
122.     }
124.     @Override
125.     public boolean hasNext() {
126.         if(index >= departments.length || departments[index] == null)
127.             return false;
128.         return true;
129.     }
131.     @Override
132.     public Object next() {
133. //        Department department = departments[index];
134. //        index++;
135.         return departments[index++];
136.         //看起来是先返回 departments[i]的值，然后才index++
137.         //其实是temp = index; temp = temp + 1; index = temp;
138.         //return departments[temp]
139.     }
141.     @Override
142.     public void remove() {//空实现
143.     }
144. }
145. /**
146. * @author 长名06
147. * @version 1.0
148. */
149. public class InfoCollegeIterator implements Iterator {
151.     //信息学院，使用集合存储系
152.     private List<Department> departmentList;
153.     private int index = -1;
155.     public InfoCollegeIterator(List<Department> departmentList) {
156.         this.departmentList = departmentList;
157.     }
159.     @Override
160.     public boolean hasNext() {
161.         if(index >= departmentList.size() - 1)
162.             return false;
163.         index += 1;
164.         return true;
165.     }
167.     @Override
168.     public Object next() {
169.         return departmentList.get(index);
170.     }
171. }
172. /**
173. * @author 长名06
174. * @version 1.0
175. */
176. public class OutputImpl {
178.     private List<College> collegeList = new ArrayList<>();
180.     public OutputImpl(List<College> list){
181.         collegeList = list;
182.     }
184.     public void printCollege(){
185.         Iterator<College> iterator = collegeList.iterator();
186.         while(iterator.hasNext()){
187.             College next = iterator.next();
188.             System.out.println("====" + next.getName() + "====");
189.             printDepartment(next.createIterator());
190.         }
191.     }
193.     public void printDepartment(Iterator iterator){
194.         while(iterator.hasNext()){
195.             Department next = (Department)iterator.next();
196.             System.out.println(next.getName() + next.getDesc());
197.         }
198.     }
200. }
201. public class Client {
202.     public static void main(String[] args) {
203.         List<College> collegeList = new ArrayList<>();
204.         ComputerCollege computerCollege = new ComputerCollege();
205.         InfoCollege infoCollege = new InfoCollege();
207.         collegeList.add(infoCollege);
208.         collegeList.add(computerCollege);
210.         OutputImpl output = new OutputImpl(collegeList);
211.         output.printCollege();
213.     }
214. }

复制代码

迭代器模式在JDK-ArrayList集合的源码分析


角色说明

• 内部类Itr充当迭代器的Iterator的实现类，作为Arraylist内部类。
  
• List就是充当了聚合接口，含有一个iterator()方法，返回一个迭代器对象
  
• ArrayList是实现了聚合接口List的子类，实现了iterator()方法
  
• Iterator接口系统提供
  

注意事项和细节

1.提供了一个统一的方法遍历对象，客户不再用考虑聚合的类型，使用一种方法就可以遍历对象了。
2.隐藏了聚合的内部结构，客户端要遍历聚合的时候只能去到迭代器，而不用知道聚合的具体组成。
3.提供了一种设计思想，就是一个类应该只有一个引起变化的原因(单一职责原则)。在聚合类中，我们把迭代器分开，就是把管理对象集合和遍历对象集合责任分开，这样依赖集合改变，只影响聚合对象。而如果遍历方式改变的话，只影响迭代器。
4.当要展示一组相似对象，或者遍历一组相同对象时使用，适合使用迭代器模式。
5.但是每个聚合对象都要一个迭代器，会存在多个迭代器类，不好管理。
只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！