设计模式之-迭代器模式

一、定义

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露该对象的内部表示。

通俗理解：就像用遥控器翻书，不需要知道书的结构，只需“下一页”“上一页”。

二、适用场景

• 需要遍历一个容器对象，但不希望暴露其内部结构；
• 需要以不同方式遍历同一个集合（如正序、逆序）；
• 集合对象需要被统一访问，而不关心其类型（如数组、链表等）；
• 避免将遍历逻辑耦合进集合本身，提高复用性。

三、核心角色

角色	说明
Iterator（抽象迭代器）	定义访问和遍历元素的接口，如 hasNext()、next()
ConcreteIterator	具体迭代器，实现遍历逻辑并记录当前位置
Aggregate（聚合接口）	定义创建迭代器的接口
ConcreteAggregate	具体聚合类，持有集合数据，并能创建对应迭代器
Client（客户端）	负责使用迭代器遍历集合

---

四、UML 类图

       +-----------------+           +-----------------------+
       |   Aggregate     |<--------+ |   ConcreteAggregate   |
       | +iterator()     |         | | +iterator()          |
       +-----------------+         | +-----------------------+
                                   |
       +-----------------+         |
       |   Iterator      |<------+ |
       | +hasNext()      |         |
       | +next()         |         |
       +-----------------+         |
                                   |
                           +-----------------------+
                           |   ConcreteIterator     |
                           | +hasNext()            |
                           | +next()               |
                           +-----------------------+

---

五、真实业务场景示例

📖 场景说明：

假设我们有一个自定义的课程集合（CourseCollection），它包含多个课程对象（Course）。我们希望通过统一方式遍历课程列表，无论课程集合底层实现是什么（List、数组、Set等）。

1. 课程实体类（非模式角色）

public class Course {
    private String name;

    public Course(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

---

2. 抽象迭代器接口（Iterator 角色）

public interface CourseIterator {
    boolean hasNext();
    Course next();
}

 3. 聚合接口（Aggregate 角色）

public interface CourseAggregate {
    void addCourse(Course course);
    void removeCourse(Course course);
    CourseIterator iterator();
}

 4. 具体聚合类（ConcreteAggregate 角色）

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

public class CourseCollection implements CourseAggregate {
    private List<Course> courseList = new ArrayList<>();

    @Override
    public void addCourse(Course course) {
        courseList.add(course);
    }

    @Override
    public void removeCourse(Course course) {
        courseList.remove(course);
    }

    @Override
    public CourseIterator iterator() {
        return new CourseListIterator(courseList);
    }
}

 5. 具体迭代器类（ConcreteIterator 角色）

import java.util.List;

public class CourseListIterator implements CourseIterator {
    private List<Course> courseList;
    private int position = 0;

    public CourseListIterator(List<Course> courseList) {
        this.courseList = courseList;
    }

    @Override
    public boolean hasNext() {
        return position < courseList.size();
    }

    @Override
    public Course next() {
        return courseList.get(position++);
    }
}

 6. 客户端代码（Client 角色）

public class IteratorClient {
    public static void main(String[] args) {
        CourseAggregate courseAggregate = new CourseCollection();
        courseAggregate.addCourse(new Course("Java 基础"));
        courseAggregate.addCourse(new Course("Spring Boot"));
        courseAggregate.addCourse(new Course("设计模式"));
        courseAggregate.addCourse(new Course("微服务架构"));

        CourseIterator iterator = courseAggregate.iterator();
        while (iterator.hasNext()) {
            Course course = iterator.next();
            System.out.println("课程名称：" + course.getName());
        }
    }
}

💡 类与角色对照表

类名	模式角色	说明
CourseIterator	Iterator	抽象迭代器接口
CourseListIterator	ConcreteIterator	具体迭代器，负责迭代逻辑
CourseAggregate	Aggregate	抽象聚合接口，定义创建迭代器的方法
CourseCollection	ConcreteAggregate	具体聚合类，实现创建迭代器及增删方法
Course	Plain Object	普通实体类，非模式角色
IteratorClient	Client	客户端，发起迭代操作

---

六、优缺点分析（Pros & Cons）

✅ 优点

1. 封装性好：不暴露集合内部结构；
2. 统一访问接口：为不同聚合结构提供统一遍历方式；
3. 符合单一职责原则：遍历逻辑独立于集合对象；
4. 支持多种遍历方式：可实现正序、逆序、自定义遍历器。

❌ 缺点

1. 类数量增多：需要为每种集合结构定义具体迭代器；
2. 开发成本略升：对于简单集合，使用 Java 内建迭代器已足够；
3. 不支持修改结构：遍历过程中修改集合结构可能导致并发问题。

---

七、现实应用场景

应用场景	描述
Java 集合框架	Iterator 、ListIterator 等接口
自定义容器结构	如图形编辑器中的图层、流程引擎节点等
多类型数据聚合	支持统一方式遍历 JSON、XML 等集合
数据处理引擎	实现步骤链或任务迭代执行

八、总结（Summary）

迭代器模式是一种非常基础但重要的行为型设计模式，它通过提供统一遍历接口，屏蔽了集合内部结构，使客户端代码更加灵活、清晰。无论是标准集合，还是自定义容器，只要你想“顺序访问”，都可以考虑使用迭代器模式。