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

小鱼儿 2022-09-10 07:17 242阅读 0赞

## 一、引言 ##

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

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

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

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

行为型又可以通过类与类之间的关系进行划分 :  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]

迭代器模式基本介绍：

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

## 二、迭代器模式 ##

### 1.迭代器模式原理类图 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

对原理类图的说明：

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

## 三、具体需求 ##

### 1.显示学校院系结构 ###

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

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

### 2.传统方案 ###

思路：

![在这里插入图片描述][1fb6fccfe70a480e86c67ad111f4992b.png_pic_center]

传统方式的问题分析：

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

### 3. 迭代器模式方案 ###

思路分析 - 类图  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

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

具体实现

// 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();
    	}
    }

## 四、注意事项和细节 ##

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]: /images/20220829/b9fd202bc07344d79e2b53740998c557.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/aecd6e00bb5e47599869ebe7c68045a8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: /images/20220829/c4a73f9af0584ef98725c5fef5b6c7f9.png
[1fb6fccfe70a480e86c67ad111f4992b.png_pic_center]: /images/20220829/37299bf68d8c43fe8bf40f296c46940a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5q2i5q2l5YmN6KGM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: /images/20220829/c712705f103a41bcbf870196791e691a.png