Java设计模式之迭代器模式_java 迭代器模式

1. 迭代器模式

1.1 定义、优缺点、适用场景

定义：迭代器模式(Iterator Pattern)属于行为型模式。如果我们的集合元素是用不同的方式实现的，有数组、集合类(ArrayList等)、其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。其提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，还不暴露集合元素的内部结构

优点：

• 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了
• 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成
• 提供了一种设计思想，就是一个类应该只有一个引起变化的原因(叫做单一责任
  原则)。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集
  合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变
  的话，只影响到了迭代器

缺点：每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类

适用场景：当要展示一组相似对象，或者遍历一组相同对象时使用

1.2 模式的结构与实现

结构：

• 迭代器接口(Iterator)：一般由java.util.Iterator提供(也可自己提供)，含有hasNext、next、remove方法
• 具体的迭代器类(ConcreteIterator)：管理迭代
• 统一的聚合接口(Aggregate)：将客户端和具体聚合解耦
• 具体的聚合持有对象集合(ConcreteAggreage)：提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合
• 客户端(Client)：通过Iterator和Aggregate依赖子类

实现：
编写程序展示一个学校院系结构。要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。其中计算机学院的各个系是数组的元素，信息工程学院的各个系是ArrayList的元素。使用迭代器进行解决

import java.util.ArrayList;
import java.util.List;

public class IteratorTest {

    public static void main(String[] args) {

        // 创建学院集合
        List<College> collegeList = new ArrayList<College>();

        ComputerCollege computerCollege = new ComputerCollege(6);
        InfoCollege infoCollege = new InfoCollege();

        collegeList.add(computerCollege);
        collegeList.add(infoCollege);

        OutPutImpl outPutImpl = new OutPutImpl(collegeList);
        outPutImpl.printCollege();
    }

}

// 学校的系
class Department {

    private String name;

    public Department(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

}

// 迭代器接口
interface Iterator<E> {

    public boolean hasNext();

    public E next();

    public void remove();
}


// 具体的迭代器类-计算机学院的数组迭代器
class ComputerCollegeIterator implements Iterator<Department> {

    // 以数组的方式存放计算机学院的系
    private Department[] departments;
    // 默认遍历的位置
    private int position = 0;


    public ComputerCollegeIterator(Department[] departments) {
        this.departments = departments;
    }

    // 判断是否还有下一个元素
    @Override
    public boolean hasNext() {
        if (this.position >= this.departments.length) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public Department next() {
        Department department = this.departments[this.position];
        this.position += 1;
        return department;
    }

    // 删除的方法，默认空实现
    public void remove() {

    }

}


// 具体的迭代器类-信息学院的List迭代器
class InfoColleageIterator implements Iterator<Department> {

    // 以List的方式存放计算机学院的系
    private List<Department> departmentList;
    // 默认遍历的位置
    private int index = 0;


    public InfoColleageIterator(List<Department> departmentList) {
        this.departmentList = departmentList;
    }

    // 判断list中还有没有下一个元素
    @Override
    public boolean hasNext() {
        if (this.index >= this.departmentList.size()) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public Department next() {
        Department department = this.departmentList.get(this.index);
        this.index += 1;
        return department;
    }

    // 删除的方法，虽然List有remove方法，但这里提供空实现
    public void remove() {

    }

}


// 统一的聚合接口-学院
interface College {

    // 获取学院的名称
    public String getName();

    // 增加系的方法
    public void addDepartment(String name);

    // 返回一个迭代器
    public Iterator createIterator();
}


// 具体的聚合持有对象集合-计算机学院
class ComputerCollege implements College {

    // 以数组的方式存放计算机学院的系，和ComputerCollegeIterator对应
    private Department[] departments;
    // 默认添加系到数组的位置
    private int positionOfDepartment = 0;


    public ComputerCollege(int DepartmentNum) {
        this.departments = new Department[DepartmentNum];
        this.addDepartment("大数据专业");
        this.addDepartment("Java专业");
        this.addDepartment("前端专业");
    }


    @Override
    public String getName() {
        return "计算机学院";
    }

    @Override
    public void addDepartment(String name) {
        Department department = new Department(name);
        this.departments[this.positionOfDepartment] = department;
        this.positionOfDepartment += 1;
    }

    // 返回一个计算机学院的系的迭代器
    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(this.departments);
    }

}


// 具体的聚合持有对象集合-信息学院
class InfoCollege implements College {

    // 以List的方式存放信息学院的系，和InfoCollegeIterator对应
    private List<Department> departmentList;


    public InfoCollege() {
        this.departmentList = new ArrayList<Department>();
        this.addDepartment("信息安全专业");
        this.addDepartment("网络安全专业");
        this.addDepartment("服务器安全专业");
    }

    @Override
    public String getName() {
        return "信息工程学院";
    }

    @Override
    public void addDepartment(String name) {
        Department department = new Department(name);
        departmentList.add(department);
    }

    // 返回一个信息学院的系的迭代器
    @Override
    public Iterator createIterator() {
        return new InfoColleageIterator(departmentList);
    }

}

// 为了方便Client使用，提供一个OutPutImpl
class OutPutImpl {

    // 学院集合
    private List<College> collegeList;

    public OutPutImpl(List<College> collegeList) {

        this.collegeList = collegeList;
    }

    // 遍历所有学院, 然后调用printDepartment输出各个学院的系
    public void printCollege() {

        // 从collegeList取出所有学院, Java中的List已经实现Iterator
        java.util.Iterator<College> javaIterator = (java.util.Iterator<College>) this.collegeList.iterator();

        while (javaIterator.hasNext()) {
            // 取出一个学院
            College college = javaIterator.next();
            System.out.println("======" + college.getName() + "======");
            // 得到学院对应迭代器，然后调用printDepartment进行打印
            this.printDepartment(college.createIterator());
        }
    }


    // 输出学院的系
    private void printDepartment(Iterator iterator) {
        while (iterator.hasNext()) {
            Department department = (Department) iterator.next();
            // 数组中获取到的department可能为null
            if (department != null) {
                System.out.println(department.getName());
            }
        }
    }

}
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248

运行程序，结果如下：

======计算机学院======
大数据专业
Java专业
前端专业
======信息工程学院======
信息安全专业
网络安全专业
服务器安全专业
1
2
3
4
5
6
7
8