设计模式-16迭代器模式

迭代器模式

基本介绍：

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

原理类图：

说明：

• Iterator：迭代器接口，是系统提供的，含有hasNext、next、remove方法
• ConcreteIterator：具体的迭代器类，用于管理迭代
• Aggregate：一个统一的聚合接口，将客户端和具体聚合解耦
• ConcreteAggregate：具体的聚合持有对象集合，并提供统一的方法，返回一个迭代器，改迭代器可以正确遍历集合
• client：客户端，通过Iterator和Aggregate依赖子类

案例：

需求：

​ 编写一个程序展示一个学院的结构，一个页面中展示出学校的原信息组成，一个学校有多个学院，一个学院有多个系

案例类图：

public class Department {

    private String name;
    private String des;

    public Department(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 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;
        }else {
            return true;
        }
    }

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

public class InfoCollegeIterator implements Iterator<Department> {

    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 interface College {

    String getName();

    void addDepartment(String name,String dsc);

    Iterator<Department> createIterator();
}

public class ComputerCollege implements College {

    private Department[] departments;
    private int numOfDepartment = 0;

    public ComputerCollege() {
        departments = new Department[5];
        addDepartment("java专业","java专业");
        addDepartment("PHP专业","PHP专业");
        addDepartment("大数据专业","大数据专业");
    }

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

    @Override
    public void addDepartment(String name, String dsc) {
        Department department = new Department(name, dsc);
        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("通信工程","通信工程");
        addDepartment("电子工程","电子工程");
        addDepartment("信息安全工程","信息安全工程");
    }

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

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

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

//打印输出类
public class OutputImpl {

    private List<College> colleges;

    public OutputImpl(List<College> colleges) {
        this.colleges = colleges;
    }

    //遍历学院
    public void printCollege() {
        Iterator<College> collegeIterator = colleges.iterator();
        while (collegeIterator.hasNext()) {
            College college = collegeIterator.next();
            System.out.println("=============" + college.getName() + "================");
            printDepartment(college.createIterator());
        }
    }

    //根据不同的迭代器遍历集合
    private void printDepartment(Iterator<Department> iterator) {
        while (iterator.hasNext()) {
            Department department = iterator.next();
            System.out.println(department.getName());
        }
    }
}

public class Client {

    public static void main(String[] args) {
        //创建学院
        InfoCollege infoCollege = new InfoCollege();
        ComputerCollege computerCollege = new ComputerCollege();

        ArrayList<College> colleges = new ArrayList<>();

        colleges.add(computerCollege);
        colleges.add(infoCollege);

        OutputImpl output = new OutputImpl(colleges);
        output.printCollege();
    }
}

源码使用说明：

JDK源码中的ArrayList就使用到了迭代器模式

说明：

• 内部类Itr充当具体实现迭代器Iterator的类，作为ArrayList的内部类
• List就是充当了聚合接口，含有一个iterator()方法，返回一个迭代器对象
• ArrayList是实现聚合接口list的子类，实现了iterator()
• Iterator接口系统提供
• 迭代器模式解决了不同集合（ArrayList、LinkedList）统一遍历

迭代器模式注意事项和细节：

优点：

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

缺点：

• 每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类