一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第1天，点击查看活动详情。
迭代器模式
前言
- 通过一个案例来说明为什么要使用迭代器模式
- 如果用传统方式来做就是学校是父类，学院继承学校，专业继承学院，这个传统的方式有一个很大的问题就是不能很好的实现遍历操作，就比如果计算机学院的专业是数组来存储的，而信息工程学院的专业是集合来存储的，这样用传统方式遍历的时候就会相当麻烦。
- 而解决的方法就是使用迭代器模式
基本介绍
- 迭代器模式是常用的设计模式，属于行为型模式
- 如果我们的集合元素是用不同的方式实现的有数组 ，还有 java 的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。
- 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即： 不暴露其内部的结构。
- 类图：
应用具体实现
-
类图：
-
代码实现：
//专业
public class Profession {
//名字
public String name;
//描述
public String des;
//构造器
public Profession(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;
}
}
//信息工程的迭代器
public class InfoCollegeIterator implements Iterator{
//底层是list集合
List<Profession> list = new ArrayList<Profession>();
//list的索引
int index = -1;
//构造器
public InfoCollegeIterator(List<Profession> list) {
this.list = list;
}
//查看是否有下一个元素
@Override
public boolean hasNext() {
if(index >= list.size()-1) {
return false;
}else {
index += 1;
return true;
}
}
//返回下一个元素
@Override
public Object next() {
return list.get(index);
}
}
//信息工程学院
public class InfoCollege implements College {
//底层是list集合
List<Profession> list;
//构造器
public InfoCollege() {
list = new ArrayList<Profession>();
addProfession("网络安全专业", "");
addProfession("信息工程", "");
}
@Override
public String getName() {
return "信息工程学院";
}
@Override
public void addProfession(String name, String des) {
Profession p = new Profession(name, des);
list.add(p);
}
@Override
public Iterator createIterator() {
return new InfoCollegeIterator(list);
}
}
//计算机学院的迭代器
public class ComputerCollegeIterator implements Iterator{
//底层是数组
Profession[] pro;
//数组索引
int index = 0;
//构造器
public ComputerCollegeIterator(Profession[] pro) {
this.pro = pro;
}
//查看是否有下一个元素
@Override
public boolean hasNext() {
if(index >= pro.length || pro[index] == null)
return false;
return true;
}
//输出下一个元素
@Override
public Object next() {
Profession p = pro[index];
index += 1;
return p;
}
//删除方法默认空实现
}
//计算机学院
public class ComputerCollege implements College {
//底层是数组
Profession[] pro;
//数组索引
int index = 0;
//构造器
public ComputerCollege() {
pro = new Profession[5];
addProfession("软件工程","");
addProfession("网络工程","");
addProfession("计算机与科学","");
}
@Override
public String getName() {
return "计算机学院";
}
@Override
public void addProfession(String name,String des) {
Profession p = new Profession(name, des);
pro[index] = p;
index += 1;
}
@Override
public Iterator createIterator() {
return new ComputerCollegeIterator(pro);
}
}
//学院的接口
public interface College {
//获取学院的名字
public String getName();
//添加专业
public void addProfession(String name,String des);
//返回一个迭代器
public Iterator createIterator();
}
//打印类
public class OutPutImpl {
//学院的集合
List<College> list;
//构造器
public OutPutImpl(List<College> list) {
this.list = list;
}
//打印学院集合
public void printCollege() {
Iterator<College> ic = list.iterator();
while(ic.hasNext()) {
College c = ic.next();
System.out.println("------"+c.getName()+"-------");
printProfession(c.createIterator());
}
}
//打印专业
public void printProfession(Iterator iterator) {
while(iterator.hasNext()) {
Profession p = (Profession)iterator.next();
System.out.println(p.getName()+": "+p.getDes());
}
}
}
//客户端
public class Client {
public static void main(String[] args) {
//创建大学中的学院
List<College> list = new ArrayList<College>();
//创建计算机学院
ComputerCollege cc = new ComputerCollege();
//创建信息工程学院
InfoCollege ic = new InfoCollege();
list.add(cc);
list.add(ic);
OutPutImpl opi = new OutPutImpl(list);
opi.printCollege();
}
}
总结
- 优 点
- 提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象了 。
- 隐藏了聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成 。
- 提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做单一责任原则 ）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器 。
- 当要展示一组相似对象，或者遍历一组相同对象时使用 , 适合使用迭代器模式
- 缺 点
- 每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类
