迭代器模式

迭代器模式

案例引入

需求

编写需求展示一个学校院系结构，需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，且多个学院，存储系的数据机构不同，有的是集合，有的是数组。

传统解决方式

让系继承学院，学院继承学校。

传统解决方式问题分析

• 1.将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。
• 2.实际上我们的要求是，在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好的实现遍历操作。
• 3.解决方案 => 迭代器模式

基本介绍

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

原理类图

原理图说明

1.Iterator迭代器接口，是系统提供的，含有hashNext()，next()，remove()等方法。
2.ConcreteIterator具体的迭代器模式，管理迭代。
3.Aggregate一个统一的聚合接口，将客户端和具体聚合解耦。
4.ConcreteAggregate具体的聚合持有对象类，并提供一个方法，返回一个迭代器，该迭代器可以正确遍历集合。
5.Client 客户端，迭代器模式使用者。

使用迭代器模式完成案例

实现类图

代码实现

/**
 * @author 长名06
 * @version 1.0
 * 学院接口
 */
public interface College {

    public String getName();

    public Iterator createIterator();

    public void addDepartment(String name,String desc);

}
/**
 * @author 长名06
 * @version 1.0
 */
public class ComputerCollege implements College{

    Department[] departments;
    int numOfDepartment = 0;

    public ComputerCollege(){
        departments = new Department[5];
        addDepartment("java专业","java语言第一");
        addDepartment("php专业","php语言第一");
        addDepartment("c++专业","c++语言第一");
    }

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

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

    @Override
    public void addDepartment(String name, String desc) {
        departments[numOfDepartment] = new Department(name,desc);
        numOfDepartment ++;
    }
}
/**
 * @author 长名06
 * @version 1.0
 */
public class InfoCollege implements College{

    private List<Department> departmentList ;

    public InfoCollege() {
        departmentList = new ArrayList<Department>();
        addDepartment("物联网工程","第一");
        addDepartment("电子信息工程","第一");
        addDepartment("通信工程","第一");
    }

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

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

    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name, desc);
        departmentList.add(department);
    }
}
/**
 * @author 长名06
 * @version 1.0
 * 系
 */
public class Department {

    private String name;

    private String desc;//描述

    public Department(String name, String desc) {
        this.name = name;
        this.desc = 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;
    }
}
/**
 * @author 长名06
 * @version 1.0
 */
public class ComputerCollegeIterator implements Iterator {

    //计算机学院使用数组存放系
    private Department[] departments;
    private int index = 0;

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

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

    @Override
    public Object next() {
//        Department department = departments[index];
//        index++;
        return departments[index++];
        //看起来是先返回 departments[i]的值，然后才index++
        //其实是temp = index; temp = temp + 1; index = temp;
        //return departments[temp]
    }

    @Override
    public void remove() {//空实现
    }
}
/**
 * @author 长名06
 * @version 1.0
 */
public class InfoCollegeIterator implements Iterator {

    //信息学院，使用集合存储系
    private List<Department> departmentList;
    private int index = -1;

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

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

    @Override
    public Object next() {
        return departmentList.get(index);
    }
}
/**
 * @author 长名06
 * @version 1.0
 */
public class OutputImpl {

    private List<College> collegeList = new ArrayList<>();

    public OutputImpl(List<College> list){
        collegeList = list;
    }

    public void printCollege(){
        Iterator<College> iterator = collegeList.iterator();
        while(iterator.hasNext()){
            College next = iterator.next();
            System.out.println("====" + next.getName() + "====");
            printDepartment(next.createIterator());
        }
    }

    public void printDepartment(Iterator iterator){
        while(iterator.hasNext()){
            Department next = (Department)iterator.next();
            System.out.println(next.getName() + next.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(infoCollege);
        collegeList.add(computerCollege);

        OutputImpl output = new OutputImpl(collegeList);
        output.printCollege();

    }
}

迭代器模式在JDK-ArrayList集合的源码分析

角色说明

• 内部类Itr充当迭代器的Iterator的实现类，作为Arraylist内部类。
• List就是充当了聚合接口，含有一个iterator()方法，返回一个迭代器对象
• ArrayList是实现了聚合接口List的子类，实现了iterator()方法
• Iterator接口系统提供

注意事项和细节

1.提供了一个统一的方法遍历对象，客户不再用考虑聚合的类型，使用一种方法就可以遍历对象了。
2.隐藏了聚合的内部结构，客户端要遍历聚合的时候只能去到迭代器，而不用知道聚合的具体组成。
3.提供了一种设计思想，就是一个类应该只有一个引起变化的原因(单一职责原则)。在聚合类中，我们把迭代器分开，就是把管理对象集合和遍历对象集合责任分开，这样依赖集合改变，只影响聚合对象。而如果遍历方式改变的话，只影响迭代器。
4.当要展示一组相似对象，或者遍历一组相同对象时使用，适合使用迭代器模式。
5.但是每个聚合对象都要一个迭代器，会存在多个迭代器类，不好管理。

只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。