笨蛋学设计模式行为型模式-迭代器模式【15】

8.2迭代器模式⬆️⬆️⬆️

8.2.1概念

​ 迭代器模式主要是提供一种统一的方式来访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示，通过使用迭代器，可以将遍历操作与聚合对象分离，使得聚合对象的结构和遍历行为能够独立变化，客户端可以顺序访问聚合对象的元素，而无需了解底层数据结构。

8.2.2场景

​ 例如在操作系统中的文件夹结构可以使用迭代器模式实现，通过迭代器模式，可以实现对文件夹中文件和子文件夹的遍历，从而无需暴露文件夹的内部实现细节，这样用户就可以方便地浏览文件夹的内容，并执行相应的操作，如复制文件、删除文件、打开文件

8.2.3优势 / 劣势

• 简化遍历操作：将遍历操作从聚合对象中抽离出来，客户端无需关心对象的内部结构，只需要通过迭代器进行遍历
• 相对独立：新增一个聚合对象或迭代器类不会影响其他的类，符合开闭原则

---

• 增加复杂度：需要引入迭代器接口和具体的迭代器实现类，增加了类的复杂度
• 不能及时修改对象：使用迭代器遍历聚合对象时，不能对聚合对象进行增删改查，否则可能会遍历出错

8.2.4迭代器模式可分为

• 迭代器接口Iterator：定义访问和遍历元素的接口，通常会包括hasNext( )方法用于检查是否还有下一个元素，以及next()方法用于获取下一个元素。有的还会实现获取第一个元素以及获取当前元素的方法
• 具体迭代器ConcreteIterator：实现迭代器接口，实现遍历逻辑对聚合对象进行遍历
• 抽象聚合类：定义了创建迭代器的接口，包括一个createIterator方法用于创建一个迭代器对象
• 具体聚合类：实现在抽象聚合类中声明的createIterator()方法，返回一个与具体聚合对应的具体迭代器

8.2.5迭代器模式

package com.technologystatck.designpattern.mode.iterators;

import java.util.ArrayList;
import java.util.List;

public class Iterators {
    public static void main(String[] args) {
        ArrayList<Object> elements = new ArrayList<>();
        elements.add("Element a");
        elements.add("Element b");
        elements.add("Element c");

        //实例化迭代器接口，创建具体的迭代器，遍历集合
        Iterable iterable = new ConcreteIterable(elements);
        Iterator iterator = iterable.createIterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

//定义迭代器接口，通常会有检查是否还会有下一个元素以及获取下一个元素的方法

//迭代器接口
interface Iterator{
    //检查是否还会有下一个元素
    boolean hasNext();

    //获取下一个元素
    Object next();
}

//定义具体迭代器：实现迭代器接口，遍历集合
class ConcreteIterator implements Iterator{

    //定义下标索引
    private int index;
    //定义list集合存放下标索引
    private List<Object> elements;

    public ConcreteIterator(List<Object> elements) {
        this.index = 0;
        this.elements = elements;
    }

    @Override
    public boolean hasNext() {
        //当索引大于集合的长度，说明遍历到头了
        return index<elements.size();
    }

    @Override
    public Object next() {
        if (hasNext()){
            //若能获取到元素就将值返回，否则就返回null
           return elements.get(index++);
        }
        return null;
    }
}

//定义聚合接口，通常包括createIterator()方法，用于创建迭代器
interface Iterable{
    Iterator createIterator();
}

//实现具体聚合，创建具体的迭代器
class ConcreteIterable implements Iterable{

    private List<Object> elements;

    //构造函数初始化可迭代对象
    public ConcreteIterable(List<Object> elements) {
        this.elements = elements;
    }
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(elements);
    }
}

8.2.6实战

8.2.6.1题目描述

小明是一位老师，在进行班级点名时，希望有一个学生名单系统，请你实现迭代器模式提供一个迭代器使得可以按顺序遍历学生列表。

8.2.6.2输入描述

第一行是一个整数 N （1 <= N <= 100), 表示学生的数量。

接下来的 N 行，每行包含一个学生的信息，格式为 姓名 学号

8.2.6.3输出描述

输出班级点名的结果，即按顺序遍历学生列表，输出学生的姓名和学号

8.2.6.4代码

package com.technologystatck.designpattern.mode.iterators;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int nums= scanner.nextInt();
        scanner.nextLine();

        StudentIterable studentIterable = new StudentIterable();

        for (int i=0;i<nums;i++){
            String[] inputs = scanner.nextLine().split(" ");
            if(inputs.length ==2){

                String studentName=inputs[0];
                int studentId=Integer.parseInt(inputs[1]);

                Student student = new Student(studentName, studentId);
                studentIterable.addStudent(student);
            }else{
                System.out.println("Invalid input");
                return;
            }
        }

        //使用迭代器遍历
        //先使用聚合接口创建迭代器
        Iterator iterator = studentIterable.createIterator();
        //只要遍历的结果不为null
        while (iterator.hasNext()){
            Student student = (Student)iterator.next();
            System.out.println(student.getStudentName()+" "+student.getStudentId());
        }

    }
}

//定义迭代器接口
interface Iterator{
    //检查是否还会有下一个元素
    boolean hasNext();

    //获取下一个元素
    Object next();
}
//定义具体迭代器
class StudentIterator implements Iterator{

    private int index;
    private List<Student> students;

    public StudentIterator() {

    }

    public StudentIterator(List<Student> students) {
        this.index = 0;
        this.students = students;
    }

    @Override
    public boolean hasNext() {
        return index<students.size();
    }

    @Override
    public Object next() {
        if(hasNext()){
            return students.get(index++);
        }
        return null;
    }
}

//定义聚合接口
interface Iterable{
    Iterator createIterator();
}

//定义学生实体聚合接口
class StudentIterable implements Iterable{

    private List<Student> students=new ArrayList<>();

    public void addStudent(Student student){
        students.add(student);
    }

    @Override
    public Iterator createIterator() {
        return new StudentIterator(students);
    }
}


//定义学生实体类
class Student{
    private String studentName;
    private int studentId;

    public Student() {
    }

    public Student(String studentName, int studentId) {
        this.studentName = studentName;
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    public int getStudentId() {
        return studentId;
    }

    public void setStudentId(int studentId) {
        this.studentId = studentId;
    }

    @Override
    public String toString() {
        return  studentName + " " + studentId ;
    }
}

8.2.7总结

• 优点：可以根据需求使用不同的迭代器实现不同的遍历逻辑，以及提高了代码的复用性
• 总结：是一种遍历一个聚合对象中的元素，而无需知道该聚合的底层表示的模式
• 场景：
  • Java语言中的集合类使用Iterator接口可以遍历集合中的元素
  • Python语言中使用iter()和next()函数用于创建和访问迭代器
  • C++语言使用begin()和end()函数获取容器的起始和结束迭代器
  • JavaScript语言新增了迭代器协议，使得遍历和访问集合元素更方便