推荐语

在这篇文章中，深入探讨了迭代器模式的核心原理和实战应用。通过清晰而有条理的解释，读者小伙伴可以领悟到迭代器模式在数据遍历和管理方面的强大能力。无论是初学者还是有经验的开发者，都能从这篇文章中获得实用的知识和技巧，进一步提升代码的可读性和可维护性。

什么是迭代器模式

迭代器模式（Iterator pattern）是一种对象行为型设计模式，它提供了一种方法来顺序访问聚合对象中的元素，而又不暴露该对象的内部表示，同时也可以将迭代逻辑与聚合对象的实现分离，增强了代码的可维护性和可扩展性。

迭代器模式的特征如下：

• 迭代器模式允许一个聚合对象公开它的每一个元素，而又不暴露其内部表示，即它提供了一种方法来遍历聚合对象中的每一个元素，而不需要了解该对象的内部结构或实现。
• 迭代器模式的主要目的是将迭代逻辑封装在迭代器对象中，而不是将该逻辑嵌入到聚合对象中。这样可以将迭代逻辑与聚合对象的实现分离，使得它们可以独立地改变和扩展。
• 迭代器模式是通过定义一个迭代器接口来实现的。该接口提供了访问和遍历聚合对象的元素的方法。聚合对象则需要实现一个能够创建相应迭代器的接口。

迭代器模式的核心原理

迭代器模式的核心原理是将数据遍历的过程封装成一个迭代器对象，以便对该数据结构进行统一的管理和操作。通过迭代器，可以实现对集合内部数据的访问，而不暴露其内部实现细节。

迭代器模式的核心角色：

1. 迭代器接口（Iterator）：定义了访问和遍历集合元素的方法，为使用者提供了一种方便的方式来遍历集合中的元素，而不必关心集合的实现细节，如：是否能够继续遍历下一个元素、取出下一个元素等。
2. 具体迭代器（ConcreteIterator）：持有一个具体的集合，并且实现了迭代器接口，实际负责按照特定的顺序遍历集合中的元素，并将遍历结果反馈给使用者。
3. 集合接口（Aggregate）：定义了创建迭代器的抽象方法，隐藏了具体集合的表示和实现，具体的表示和实现由具体集合类来负责实现；
4. 具体集合（ConcreteAggregate）：该类实现了集合接口，创建出具体的迭代器对象，供使用者通过迭代器来访问和遍历集合元素。当然，作为具体集合，需要提供具体的添加、移除、查询集合长度的具体方法；

迭代器模式如何实现

需求描述

回想在上大学的时候，老师在教学活动中都会拥有一个学生的花名册，上面有学生的姓名、学号等信息，每次上课前都要先按照名册上记录的顺序逐一点名，如果帮老师写一个自动点名的程序，那么这个时候使用迭代器模式绝对是非常不错的一个选择。那么具体怎么实现呢？

实现方法

1、定义一个迭代器接口，即名册迭代器接口，主要有两个抽象方法：判断是否下一个元素可以遍历、遍历取出下一个元素；

/**
 * 名删除迭代器抽象接口
 * @param <T>
 */
public interface RosterInterator<T> {
    /**
     * 是否有下一个元素
     * @return
     */
    boolean hasNext();

    /**
     * 取出下一个元素
     * @return
     */
    T next();
}

2、定义一个集合接口：抽象名册接口，定义一个抽象方法：获取名册迭代器；

/**
 * 名册
 */
public interface Roster<T> {
    /**
     * 获取迭代器
     * @return
     */
    RosterInterator<T> getInterator();
}

3、定义具体的集合，即具体的学生名册类，具体的学生名册类除了正常可以往学生名册上添加、移除学生，查询学生名册上人员数量方法外，还要实现抽象名册接口的获取名册迭代器的方法，在方法中创建具体的迭代器对象；

/**
 * 学生类
 */
@Data
public class Student {
    private String stuNo;
    private String name;

    public Student(String stuNo, String name) {
        this.stuNo = stuNo;
        this.name = name;
    }
}

/**
 * 学生名册
 */
@Data
public class StudentRoster implements Roster<Student>{
    /**
     * 学生对象集合
     */
    private List<Student> list=new ArrayList<>();

    /**
     * 添加学生
     * @param student
     */
    public void add(Student student){
        this.list.add(student);
    }

    /**
     * 移除学生
     * @param student
     */
    public void remove(Student student){
        this.list.remove(student);
    }

    /**
     * 学生名册学生对象数量
     * @return
     */
    public Integer size(){
        return this.list.size();
    }
    @Override
    public RosterInterator<Student> getInterator() {
        return new StudentRosterInterator(this);
    }
}

4、定义集合迭代器实现，即具体的学生名册迭代器，具体的学生迭代器会持有具体的学生名册，并实现名册迭代器定义的两个抽象方法，即具体的判断是否有下一个元素可以遍历、遍历取出下一个元素；

/**
 * 学生名册迭代器
 */
@Data
public class StudentRosterInterator implements RosterInterator<Student>{
    /**
     * 学生名册
     */
    private StudentRoster roster;
    /**
     * 索引位置
     */
    private Integer index=0;

    public StudentRosterInterator(StudentRoster roster) {
        this.roster = roster;
    }

    @Override
    public boolean hasNext() {
        return this.roster.size() > index;
    }

    @Override
    public Student next() {
        Student student = this.roster.getList().get(index);
        index++;
        return student;
    }
}

5、编写客户端类

public class StudentClient {
    public static void main(String[] args) {
        StudentRoster studentRoster=new StudentRoster();
        Student stu1 = new Student("s001", "小明");
        Student stu2 = new Student("s002", "小红");
        Student stu3 = new Student("s003", "小刚");
        studentRoster.add(stu1);
        studentRoster.add(stu2);
        studentRoster.add(stu3);
        RosterInterator<Student> rosterInterator=new StudentRosterInterator(studentRoster);
        while (rosterInterator.hasNext()) {
            Student student = rosterInterator.next();
            System.out.println(student.getStuNo()+":"+student.getName());
        }
    }
}

如何扩展

老师上课的时候会根据学生画名册点名，那么学校领导在给老师们开会的时候，有没有可能也会点一个名，看年哪位老师没有到？当然会。假如也要帮校长实现一个对老师们的点名程序，应该怎么在原先的基础上扩展呢？其实很简单，保持原有的抽象名册迭代器接口、抽象名册接口不变，再分别实现老师画名册、老师画名册迭代器就可。而且这一过程完全符合开闭原则，不会对原来的程序造成任何影响，这就是设计模式的魅力。

/**
 * 老师类
 */
@Data
public class Teacher {
    private String teacNo;
    private String name;

    public Teacher(String teacNo, String name) {
        this.teacNo = teacNo;
        this.name = name;
    }
}

import java.util.ArrayList;

/**
 * 老师名册
 */
@Data
public class TeacherRoster implements Roster<Teacher>{
    /**
     * 老师对象集合
     */
    private List<Teacher> list=new ArrayList<>();

    /**
     * 添加老师
     * @param teacher
     */
    public void add(Teacher teacher){
        this.list.add(teacher);
    }

    /**
     * 移除老师
     * @param teacher
     */
    public void remove(Teacher teacher){
        this.list.remove(teacher);
    }

    /**
     * 老师名册中对象数量
     * @return
     */
    public Integer size(){
        return this.list.size();
    }

    @Override
    public RosterInterator<Teacher> getInterator() {
        return new TeacherRosterInterator(this) ;
    }
}

/**
 * 老师名册迭代器
 */
@Data
public class TeacherRosterInterator implements RosterInterator<Teacher> {

    private TeacherRoster teacherRoster;
    private Integer index = 0;


    public TeacherRosterInterator(TeacherRoster teacherRoster) {
        this.teacherRoster = teacherRoster;
    }

    @Override
    public boolean hasNext() {
        return this.teacherRoster.size() > index;
    }

    @Override
    public Teacher next() {
        Teacher teacher = this.teacherRoster.getList().get(index);
        index++;
        return teacher;
    }
}

public class TeacherClent {
    public static void main(String[] args) {
        TeacherRoster teacherRoster=new TeacherRoster();
        Teacher t1 = new Teacher("t001", "王老师");
        Teacher t2 = new Teacher("t002", "李老师");
        Teacher t3 = new Teacher("t003", "张老师");
        teacherRoster.add(t1);
        teacherRoster.add(t2);
        teacherRoster.add(t3);
        RosterInterator<Teacher> rosterInterator=new TeacherRosterInterator(teacherRoster);
        while (rosterInterator.hasNext()) {
            Teacher teacher = rosterInterator.next();
            System.out.println(teacher.getTeacNo()+":"+teacher.getName());
        }
    }
}

迭代器模式的适用场景

业务场景具有下面的特征就可以使用迭代器模式：

• 需要遍历集合对象中的元素，而不暴露该对象的内部表示的场景。通过使用迭代器模式，可以在不暴露集合对象内部结构的情况下，顺序访问集合对象中的各个元素。
• 需要为遍历不同的集合结构提供统一接口的场景。迭代器模式可以提供一种统一的接口，用于遍历不同的集合结构，从而使得代码更加灵活和可扩展。

有没有比较具体的业务场景示例呢？当然有，比如：

1. 在物流系统中，可以使用迭代器模式来遍历物品。例如，在传送带上，不管传送的是什么物品，都被打包成一个一个的箱子并且有一个统一的二维码。这样我们不需要关心箱子里是什么物品，只需要一个一个检查发送的目的地即可。
2. 在图片播放器中，可以使用迭代器模式来遍历图片。这样可以在不暴露图片内部结构的情况下，顺序访问图片中的各个元素。
3. 图书馆管理系统：在图书馆中，需要对书籍进行遍历，可以使用迭代器模式来处理。通过定义一个统一的迭代器接口，不同的数据结构（如数组、链表等）都可以使用相同的迭代器接口来遍历书籍，同时保持内部实现的封装。
4. 电商网站：在电商网站中，通常需要对商品进行展示和遍历。使用迭代器模式可以实现对商品的顺序访问，而不暴露商品内部表示。
5. 金融系统：在金融系统中，需要对账户、交易等进行处理。使用迭代器模式可以实现对账户或交易的顺序访问，而不暴露其内部表示。
6. 音乐播放器：在音乐播放器中，需要遍历音乐库中的歌曲。使用迭代器模式可以实现对歌曲的顺序访问，而不暴露歌曲内部表示。

总结

优点

1. 分离集合与迭代逻辑：迭代器模式将集合对象与遍历逻辑分离，使得它们可以独立变化。集合对象只需要实现迭代器接口，而客户端只需要通过迭代器进行遍历操作，从而实现了解耦和模块化。
2. 统一遍历接口：迭代器模式定义了一组统一的遍历接口，使得客户端可以以相同的方式对待不同类型的集合对象。无论是数组、链表、树状结构还是其他自定义集合，只要它们提供了符合迭代器接口的迭代器对象，就可以使用迭代器模式进行遍历，提高了代码的灵活性和可复用性。
3. 简化客户端代码：使用迭代器模式可以简化客户端代码，减少了对集合内部结构的直接操作，只需要通过迭代器对象进行遍历操作。

缺点

1. 可能增加代码复杂度：使用迭代器模式可能会增加一些额外的代码复杂度，例如需要定义迭代器接口、具体迭代器实现类等。
2. 限制集合对象的类型：迭代器模式通常只适用于集合类型的聚合对象，不能很好地处理其他类型的聚合对象，例如树形结构、图形结构等。
3. 可能增加内存开销：使用迭代器模式可能会增加一些额外的内存开销，例如需要创建迭代器对象等。

总之，迭代器模式在许多业务场景中都有应用，可以实现对集合对象的顺序访问，而不暴露其内部表示，可以使得代码更加清晰、简洁、易于维护。