迭代器模式_迭代器模式提高了遍历效率-优快云博客

展示学校院系系统

展示学校院系系统，展示一个学校要多少学院、一个学院有多少个系。

迭代器模式

提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要指导集合对象的底层。

当我们集合元素是用不同的方式实现，比如数组、集合类等，当客户端需要遍历时，便会使用多种迭代方法，则容易暴露元素的内部结构，此时便可考虑迭代器模式

迭代器模式结构

在这里插入图片描述

1.迭代器（Iterator）接口声明了遍历集合所需的操作：获取下一个元素、获取当前位置和重新开始迭代等。

2.具体迭代器（Concrete Iterators） 实现遍历集合的一种特定算法。迭代器对象必须跟踪自身遍历的进度。这使得多个迭代器可以相互独立地遍历同一集合。

3.集合（Collection） 接口声明一个或多个方法来获取与集合兼容的迭代器。请注意，返回方法的类型必须被声明为迭代器接口，因此具体集合可以返回各种不同种类的迭代器。

4.具体集合（Concrete Collections）会在客户端请求迭代器时返回一个特定的具体迭代器类实体。你可能会琢磨，剩下的集合代码在什么地方呢？不用担心，它也会在同一个类中。只是这些细节对于实际模式来说并不重要，所以我们将其省略了而已。

迭代器模式适合应用场景

1.当集合背后为复杂的数据结构，且你希望对客户端隐藏其复杂性时（出于使用便利性或安全性的考虑），可以使用迭代器模式。

2.使用该模式可以减少程序中重复的遍历代码。

3.如果你希望代码能够遍历不同的甚至是无法预知的数据结构，可以使用迭代器模式。

实现方式

1.声明迭代器接口。该接口必须提供至少一个方法来获取集合中的下个元素。但为了使用方便，你还可以添加一些其他方法，例如获取前一个元素、记录当前位置和判断迭代是否已结束。

2.声明集合接口并描述一个获取迭代器的方法。其返回值必须是迭代器接口。如果你计划拥有多组不同的迭代器，则可以声明多个类似的方法。

3.为希望使用迭代器进行遍历的集合实现具体迭代器类。迭代器对象必须与单个集合实体链接。链接关系通常通过迭代器的构造函数建立。

4.在你的集合类中实现集合接口。其主要思想是针对特定集合为客户端代码提供创建迭代器的快捷方式。集合对象必须将自身传递给迭代器的构造函数来创建两者之间的链接。

5.检查客户端代码，使用迭代器替代所有集合遍历代码。每当客户端需要遍历集合元素时都会获取一个新的迭代器。

迭代器模式优缺点

优点：

✔️ 单一职责原则。通过将体积庞大的遍历算法代码抽取为独立的类，你可对客户端代码和集合进行整理。

✔️ 开闭原则。你可实现新型的集合和迭代器并将其传递给现有代码，无需修改现有代码。

✔️ 你可以并行遍历同一集合，因为每个迭代器对象都包含其自身的遍历状态。

✔️ 相似的，你可以暂停遍历并在需要时继续。

缺点：

❌ 如果你的程序只与简单的集合进行交互，应用该模式可能会矫枉过正。

❌ 对于某些特殊集合，使用迭代器可能比直接遍历的效率低。

解决展示学校院系系统

在这里插入图片描述

//系
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;
    }
}

public class ComputerCollegeIterator implements Iterator {
    //利用数组 存放Department
    Department[] departments;
    int index = 0; //遍历的位置

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

    //是否存在下个元素
    @Override
    public boolean hasNext() {
        if (index >= departments.length || departments[index] == null){
            return false;
        }else {
            return true;
        }
    }

    //下一个元素
    @Override
    public Object next() {
        Department department = departments[index];
        index += 1;
        return department;
    }

}

public class InfoColleageIterator implements Iterator {
    //利用List 存放系
    List<Department> list;
    int index = -1;

    public InfoColleageIterator(List<Department> list) {
        this.list = list;
    }

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

    @Override
    public Object next() {
        return list.get(index);
    }


}

public interface College {
    public String getName();

    //增加系方法
    public void addDepartment(String name,String desc);

    //返回一个迭代器，遍历
    public Iterator createIterator();
}


public class ComputerCollege implements College {
    Department[] departments; //数组的形式
    int index = 0;

    ComputerCollege(){
        departments = new Department[5];
    }

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

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

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

public class InfoCollege implements College {

    List<Department> list;

    InfoCollege(){
        list = new ArrayList<>();
    }

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

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

    @Override
    public Iterator createIterator() {
        return new InfoColleageIterator(list);
    }
}

public class OutputImpl {

    //学院集合
    List<College> collegesList;

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

    //输出学院
    public void printCollege(){
        //从list中取出所有学院，由于所有的相关类都重写了迭代器
        Iterator<College> iterator = collegesList.iterator();

        while (iterator.hasNext()){
            College college = iterator.next();
            System.out.println("---"+college.getName()+"---");
            printDepartment(college.createIterator()); //获取迭代器来输出系
        }
    }

    public void printDepartment(Iterator iterator){
        while (iterator.hasNext()){
            Department d = (Department) iterator.next();
            System.out.println(d.getName());
        }
    }
}

public class Client {
    public static void main(String[] args) {
        List<College> list = new ArrayList<>();

        ComputerCollege computerCollege = new ComputerCollege();
        computerCollege.addDepartment("Java","");
        computerCollege.addDepartment("PHP","");
        computerCollege.addDepartment("JS","");

        InfoCollege infoCollege = new InfoCollege();
        infoCollege.addDepartment("通信工程","");
        infoCollege.addDepartment("网络工厂","");

        list.add(computerCollege);
        list.add(infoCollege);

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