迭代器模式
案例引入
需求
编写需求展示一个学校院系结构，需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，且多个学院，存储系的数据机构不同，有的是集合，有的是数组。
传统解决方式
让系继承学院，学院继承学校。
传统解决方式问题分析
- 1.将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。
- 2.实际上我们的要求是，在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好的实现遍历操作。
- 3.解决方案 => 迭代器模式
基本介绍
- 1.迭代器模式(Iterator Pattern)是常用的设计模式，属于行为模式。
- 2.如果我们的集合元素使用不同的方式实现的，有数组，还有java的集合类，或者还有其他的方式，当客户端要遍历这些元素的时候，就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。
- 3.迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法，遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部结构。
原理类图
原理图说明
1.Iterator迭代器接口，是系统提供的，含有hashNext()，next()，remove()等方法。
2.ConcreteIterator具体的迭代器模式，管理迭代。
3.Aggregate一个统一的聚合接口，将客户端和具体聚合解耦。
4.ConcreteAggregate具体的聚合持有对象类，并提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合。
5.Client 客户端，迭代器模式使用者。
使用迭代器模式完成案例
实现类图
代码实现
/**
* @author 长名06
* @version 1.0
* 学院接口
*/
public interface College {
public String getName();
public Iterator createIterator();
public void addDepartment(String name,String desc);
}
/**
* @author 长名06
* @version 1.0
*/
public class ComputerCollege implements College{
Department[] departments;
int numOfDepartment = 0;
public ComputerCollege(){
departments = new Department[5];
addDepartment("java专业","java语言第一");
addDepartment("php专业","php语言第一");
addDepartment("c++专业","c++语言第一");
}
@Override
public String getName() {
return "计算机学院";
}
@Override
public Iterator createIterator() {
return new ComputerCollegeIterator(departments);
}
@Override
public void addDepartment(String name, String desc) {
departments[numOfDepartment] = new Department(name,desc);
numOfDepartment ++;
}
}
/**
* @author 长名06
* @version 1.0
*/
public class InfoCollege implements College{
private List<Department> departmentList ;
public InfoCollege() {
departmentList = new ArrayList<Department>();
addDepartment("物联网工程","第一");
addDepartment("电子信息工程","第一");
addDepartment("通信工程","第一");
}
@Override
public String getName() {
return "信息工程学院";
}
@Override
public Iterator createIterator() {
return new InfoCollegeIterator(departmentList);
}
@Override
public void addDepartment(String name, String desc) {
Department department = new Department(name, desc);
departmentList.add(department);
}
}
/**
* @author 长名06
* @version 1.0
* 系
*/
public class Department {
private String name;
private String desc;//描述
public Department(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
/**
* @author 长名06
* @version 1.0
*/
public class ComputerCollegeIterator implements Iterator {
//计算机学院使用数组存放系
private Department[] departments;
private int index = 0;
public ComputerCollegeIterator(Department[] departments) {
this.departments = departments;
}
@Override
public boolean hasNext() {
if(index >= departments.length || departments[index] == null)
return false;
return true;
}
@Override
public Object next() {
// Department department = departments[index];
// index++;
return departments[index++];
//看起来是先返回 departments[i]的值，然后才index++
//其实是temp = index; temp = temp + 1; index = temp;
//return departments[temp]
}
@Override
public void remove() {//空实现
}
}
/**
* @author 长名06
* @version 1.0
*/
public class InfoCollegeIterator implements Iterator {
//信息学院，使用集合存储系
private List<Department> departmentList;
private int index = -1;
public InfoCollegeIterator(List<Department> departmentList) {
this.departmentList = departmentList;
}
@Override
public boolean hasNext() {
if(index >= departmentList.size() - 1)
return false;
index += 1;
return true;
}
@Override
public Object next() {
return departmentList.get(index);
}
}
/**
* @author 长名06
* @version 1.0
*/
public class OutputImpl {
private List<College> collegeList = new ArrayList<>();
public OutputImpl(List<College> list){
collegeList = list;
}
public void printCollege(){
Iterator<College> iterator = collegeList.iterator();
while(iterator.hasNext()){
College next = iterator.next();
System.out.println("====" + next.getName() + "====");
printDepartment(next.createIterator());
}
}
public void printDepartment(Iterator iterator){
while(iterator.hasNext()){
Department next = (Department)iterator.next();
System.out.println(next.getName() + next.getDesc());
}
}
}
public class Client {
public static void main(String[] args) {
List<College> collegeList = new ArrayList<>();
ComputerCollege computerCollege = new ComputerCollege();
InfoCollege infoCollege = new InfoCollege();
collegeList.add(infoCollege);
collegeList.add(computerCollege);
OutputImpl output = new OutputImpl(collegeList);
output.printCollege();
}
}
迭代器模式在JDK-ArrayList集合的源码分析
角色说明
- 内部类Itr充当迭代器的Iterator的实现类，作为Arraylist内部类。
- List就是充当了聚合接口，含有一个iterator()方法，返回一个迭代器对象
- ArrayList是实现了聚合接口List的子类，实现了iterator()方法
- Iterator接口系统提供
注意事项和细节
1.提供了一个统一的方法遍历对象，客户不再用考虑聚合的类型，使用一种方法就可以遍历对象了。
2.隐藏了聚合的内部结构，客户端要遍历聚合的时候只能去到迭代器，而不用知道聚合的具体组成。
3.提供了一种设计思想，就是一个类应该只有一个引起变化的原因(单一职责原则)。在聚合类中，我们把迭代器分开，就是把管理对象集合和遍历对象集合责任分开，这样依赖集合改变，只影响聚合对象。而如果遍历方式改变的话，只影响迭代器。
4.当要展示一组相似对象，或者遍历一组相同对象时使用，适合使用迭代器模式。
5.但是每个聚合对象都要一个迭代器，会存在多个迭代器类，不好管理。
只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。
