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 collegeList = new ArrayList();

        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 {

    public boolean hasNext();

    public E next();

    public void remove();
}


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

    // 以数组的方式存放计算机学院的系
    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 {

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


    public InfoColleageIterator(List 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 departmentList;


    public InfoCollege() {
        this.departmentList = new ArrayList();
        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 collegeList;

    public OutPutImpl(List collegeList) {

        this.collegeList = collegeList;
    }

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

        // 从collegeList取出所有学院, Java中的List已经实现Iterator
        java.util.Iterator javaIterator = (java.util.Iterator) 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());
            }
        }
    }

}

运行程序，结果如下：

======计算机学院======
大数据专业
Java专业
前端专业
======信息工程学院======
信息安全专业
网络安全专业
服务器安全专业