设计模式之迭代器模式

迭代器模式

行为型模式

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

介绍

意图： 提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要解决： 不同的方式来遍历整个整合对象。

何时使用： 遍历一个聚合对象。

如何解决： 把在元素之间游走的责任交给迭代器，而不是聚合对象。

关键代码： 定义接口：hasNext, next。

应用实例： JAVA 中的 iterator。

具体实现

我们在控制台需要输出一个学校的院系组成，一个学校有多个学院，一个学院有多个系。

第一步：创建系

public class Department {

    private String name;
    private String 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;
    }

    public Department(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
}

第二步：创建学院接口

public interface College {

    String getName();

    /**
     * 增加系
     */
    void addDepartment(String name, String desc);

    //返回一个迭代器
    Iterator<Department> createIterator();

}

第三步：创建不同院系的实现类

public class ComputerCollege implements College {

    private Department[] departments;
    //保存当前数组对象的个数
    private int numOfDepartment = 0;

    public ComputerCollege() {
        departments = new Department[5];
        addDepartment("Java", "很棒");
        addDepartment("PHP", "不行");
        addDepartment("Python", "也很棒");
        addDepartment("JS", "也是很棒");
    }

    @Override
    public String getName() {
        return "计算机学院";
    }

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

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

public class InfoCollege implements College {

    private List<Department> departments;

    public InfoCollege() {
        departments = new ArrayList<>();
        addDepartment("信息安全专业", "很棒");
        addDepartment("网络安全专业", "good");
        addDepartment("服务器安全专业", "也很棒");
    }

    @Override
    public String getName() {
        return "信息学院";
    }

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

    @Override
    public Iterator<Department> createIterator() {
        return new InfoCollegeIterator(departments);
    }
}

第四步：创建不同学院的迭代器实现Iterator接口

public class ComputerCollegeIterator implements Iterator<Department> {

    //这里我们需要知道Department是以怎样的方式存放
    private Department[] departments;
    //遍历的位置
    private int position = 0;

    public ComputerCollegeIterator(Department[] departments) {
        this.departments = departments;
    }

    @Override
    public boolean hasNext() {
        if (position >= departments.length || departments[position] == null) {
            return false;
        }
        return true;
    }

    @Override
    public Department next() {
        Department department = departments[position];
        position += 1;
        return department;
    }
}

public class InfoCollegeIterator implements Iterator<Department> {

    //信息工程学院是以List的方式存放系
    private List<Department> departments;
    //索引
    private int index = -1;

    public InfoCollegeIterator(List<Department> departments) {
        this.departments = departments;
    }


    @Override
    public boolean hasNext() {
        if (index >= departments.size() - 1) {
            return false;
        } else {
            index += 1;
            return true;
        }
    }

    @Override
    public Department next() {
        return departments.get(index);
    }
}

第五步：创建输出类

public class OutPutImpl {

    //学院的集合
    private List<College> collegeList;

    public OutPutImpl(List<College> collegeList) {
        this.collegeList = collegeList;
    }

    //遍历所有学院,然后调用printDepartment输出系
    public void printCollege() {
        Iterator<College> iterator = collegeList.iterator();
        while (iterator.hasNext()) {
            College college = iterator.next();
            System.out.println("---------学院名称:" + college.getName() + "---------");
            printDepartment(college.createIterator());
        }
    }

    //输出 系
    public void printDepartment(Iterator<Department> iterator) {
        while (iterator.hasNext()) {
            Department department = iterator.next();
            System.out.println("系名称:" + department.getName() + ",简介:" + department.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(computerCollege);
        collegeList.add(infoCollege);
        OutPutImpl outPut = new OutPutImpl(collegeList);
        outPut.printCollege();
    }
}

运行如下：

---------学院名称:计算机学院---------
系名称:Java,简介:很棒
系名称:PHP,简介:不行
系名称:Python,简介:也很棒
系名称:JS,简介:也是很棒
---------学院名称:信息学院---------
系名称:信息安全专业,简介:很棒
系名称:网络安全专业,简介:good
系名称:服务器安全专业,简介:也很棒

优点：

    1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：

    由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。