Java设计模式——迭代器模式【Iterator Pattern】

一、引言

23种设计模式大概分为三大类：

5种（创建型模式）：工厂方法模式、抽象工厂模式、单例模式、原型模式、建造者模式。

7种（结构型模式）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

11种（行为型模式）：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

行为型又可以通过类与类之间的关系进行划分 :

迭代器模式基本介绍：

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

二、迭代器模式

1.迭代器模式原理类图

对原理类图的说明：

• Iterator：迭代器接口，是由系统提供的，含有hasNext, next, remove方法
• ConcreteIterator：具体的迭代器类，实现迭代器接口，管理迭代
• Aggregate：一个统一的聚合接口，将客户端和具体的聚合解耦
• ConcreteAggreage：具体的聚合持有对象集合，并提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合(因为每个迭代器都和聚合有对应关系)
• Client：客户端，通过 Iterator 和 Aggregate 来依赖它们的子类

三、具体需求

1.显示学校院系结构

编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院， 一个学院有多个系。(组合模式也使用了该案例，此处侧重于遍历) 如图：

2.传统方案

思路：

传统方式的问题分析：

• 将学院看做是学校的子类，系看做学院的子类，这样实际上是站在组织大小来进行分层次的
• 实际上我们的要求是 ：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现的遍历的操作
• 假设：计算机学院是存放在数组中的，信息工程学院是存放在集合中的，怎样通过一个统一的方式来访问它们呢？解决方案：=> 迭代器模式

3. 迭代器模式方案

思路分析 - 类图

将数据和遍历方式分开，左半部分是数据，右半部分是遍历

具体实现

// Department.java
public class Department {
	private String name;
	private String des;
	public Department(String name, String des) {
		this.name = name;
		this.des = des;
	}
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
	public String getDes() { return des; }
	public void setDes(String des) { this.des = des; }
}

// ComputerCollegeIterator.java
public class ComputerCollegeIterator implements Iterator {
	//因为迭代器的迭代方式与集合内部的存放方式有关，因此需要知道Department是怎样存放的
	Department[] departments;
	int position = 0;//遍历的位置
	
	public ComputerCollegeIterator(Department[] departments) {
		this.departments = departments;
	}

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

	@Override
	public Object next() {
		Department department = departments[position];
		position++;
		return department;
	}
	
	//删除方法默认空实现
	@Override
	public void remove() {
	}
}

// InfoCollegeIterator.java
public class InfoCollegeIterator implements Iterator {
	//信息工程学院的系是以List形式存放的
	List<Department> departmentList;
	int index = -1;//索引
	
	public InfoCollegeIterator(List<Department> departmentList) {
		this.departmentList = departmentList;
	}

	//判断是否还有下一个元素
	@Override
	public boolean hasNext() {
		if(index >= departmentList.size()-1) {
			return false;
		}else {
			index+=1;
			return true;
		}
	}

	@Override
	public Object next() {
		return departmentList.get(index);
	}
	//删除方法默认空实现
	@Override
	public void remove() {
	}
}

// College.java
public interface College {
	public String getName();
	//增加系
	public void addDepartment(String name, String desc);
	//返回一个迭代器
	public Iterator createIterator();
}

// ComputerCollege.java
public class ComputerCollege implements College {
	Department[] departments;
	int numOfDepartment = 0;//保存当前数组的对象个数
	
	public ComputerCollege() {
		//先假定最多存放5个系
		departments = new Department[5];
		addDepartment("Java专业", "Java");
		addDepartment("PHP专业", "PHP");
		addDepartment("大数据专业", "大数据");
	}
	
	@Override
	public String getName() { return "计算机学院"; }

	@Override
	public void addDepartment(String name, String desc) {
		Department department = new Department(name, desc);
		departments[numOfDepartment] = department;
		numOfDepartment++;
	}

	@Override
	public Iterator createIterator() {
		return new ComputerCollegeIterator(departments);
	}
}

// InfoCollege.java
public class InfoCollege implements College {
	List<Department> departmentList;
	
	public InfoCollege() {
		departmentList = new ArrayList<Department>();
		addDepartment("信息安全专业", "信息安全");
		addDepartment("网络安全专业", "网络安全");
	}
	
	@Override
	public String getName() { return "信息工程学院"; }

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

	@Override
	public Iterator createIterator() {
		return new InfoCollegeIterator(departmentList);
	}
}

// OutputImpl.java
public class OutputImpl {
	//学院集合
	List<College> collegeList;
	
	public OutputImpl(List<College> collegeList) {
		this.collegeList = collegeList;
	}
	
	//遍历所有的学院，然后调用printDepartment,输出各个学院的系
	public void printCollege() {
		//从collegeList中取出所有学院
		//Java中的List已经实现了Iterator接口,所以可以直接用
		Iterator<College> iterator = collegeList.iterator();
		while(iterator.hasNext()) {
			College college = iterator.next();
			System.out.println("======"+college.getName()+"======");
			printDepartment(college.createIterator());//得到对应的迭代器
		}
	}
	
	//学院输出系
	public void printDepartment(Iterator iterator) {
		while(iterator.hasNext()) {
			//因为取出来是Object，所以需要强转
			Department d = (Department) iterator.next();
			System.out.println(d.getName());
		}
	}
}

// Client.java
public class Client {
	public static void main(String[] args) {
		//创建学院
		List<College> collegeList = new ArrayList<College>();
		
		College computerCollege = new ComputerCollege();
		InfoCollege infoCollege = new InfoCollege();
		
		collegeList.add(computerCollege);
		collegeList.add(infoCollege);
		
		OutputImpl outputImpl = new OutputImpl(collegeList);
		outputImpl.printCollege();
	}
}

四、注意事项和细节

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