迭代器模式

迭代器模式

案例引入

需求

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

传统解决方式

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

传统解决方式问题分析
  • 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.但是每个聚合对象都要一个迭代器,会存在多个迭代器类,不好管理。

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

热门相关:总裁的天价小妻子   楚氏赘婿   我是仙凡   重生之女将星   精灵掌门人