【设计模式】行为型-迭代器模式

文章目录

前言
一、概念
二、核心结构
[三、Java 代码实现（简易 ArrayList 迭代器）](#三、Java 代码实现（简易 ArrayList 迭代器）)
- [1. 抽象迭代器](#1. 抽象迭代器)
- [2. 抽象聚合（容器）](#2. 抽象聚合（容器）)
- [3. 具体容器（模拟 ArrayList）](#3. 具体容器（模拟 ArrayList）)
- [4. 客户端遍历](#4. 客户端遍历)
四、内部类实现迭代器的好处
[五、Java 内置迭代器（实际开发几乎都用这个）](#五、Java 内置迭代器（实际开发几乎都用这个）)
六、优缺点
- 优点
- 缺点
七、应用场景
[八、迭代器模式 VS 其他模式](#八、迭代器模式 VS 其他模式)
九、总结

前言

在开发中，我们几乎天天和集合打交道：List、Set、Map、数组、树、图......不同集合的存储结构、遍历方式完全不同 ，如果让客户端直接去遍历各种复杂结构，代码会严重耦合、难以扩展。迭代器模式就是专门封装集合遍历细节、统一遍历接口的行为型设计模式，让我们能用同一套代码遍历任意容器，而不用关心底层结构。

一、概念

迭代器模式（Iterator Pattern） 是一种行为型设计模式 ，核心思想：
提供一种方法顺序访问一个聚合对象（集合/容器）中的各个元素，而又不暴露该对象的内部表示。

简单理解：

把怎么遍历 抽成独立的迭代器类；
容器只负责存数据，迭代器负责遍历数据；
客户端只用 hasNext()、next() 就能遍历任何容器。

一句话总结：
统一遍历行为，隔离容器结构，让遍历与集合解耦。

二、核心结构

Iterator（抽象迭代器）
定义遍历接口：hasNext()、next() 等。
ConcreteIterator（具体迭代器）
实现迭代逻辑，记录当前遍历位置。
Aggregate（抽象聚合/容器）
定义创建迭代器的接口。
ConcreteAggregate（具体聚合/容器）
实现容器，返回对应的迭代器。
Client（客户端）
面向迭代器编程，统一遍历。

三、Java 代码实现（简易 ArrayList 迭代器）

实现一个自定义数组容器 + 自定义迭代器。

1. 抽象迭代器

java 复制代码

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

2. 抽象聚合（容器）

java 复制代码

public interface Aggregate<T> {
    Iterator<T> createIterator();
    void add(T t);
}

3. 具体容器（模拟 ArrayList）

java 复制代码

public class MyArrayList<T> implements Aggregate<T> {

    private Object[] items = new Object[10];
    private int size = 0;

    @Override
    public void add(T t) {
        items[size++] = t;
    }

    @Override
    public Iterator<T> createIterator() {
        return new MyArrayListIterator();
    }

    // 具体迭代器（内部类，方便访问容器数据）
    private class MyArrayListIterator implements Iterator<T> {

        private int index = 0;

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

        @Override
        @SuppressWarnings("unchecked")
        public T next() {
            return (T) items[index++];
        }
    }
}

4. 客户端遍历

java 复制代码

public class Client {
    public static void main(String[] args) {
        Aggregate<String> list = new MyArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        // 获取迭代器统一遍历
        Iterator<String> iterator = list.createIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

输出：

复制代码

A
B
C

四、内部类实现迭代器的好处

迭代器需要频繁访问容器内部元素，内部类可直接访问私有成员；
迭代器与容器绑定，对外隐藏实现细节；
一个容器可以提供多个迭代器（正序、倒序、随机遍历）。

五、Java 内置迭代器（实际开发几乎都用这个）

Java 集合框架完全基于迭代器模式实现：

java.util.Iterator
java.util.ListIterator
Iterable 接口（Collection 继承它）

日常写法：

java 复制代码

List<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

// 增强for循环底层也是迭代器
for (String s : list) {
}

六、优缺点

优点

统一遍历接口，遍历任意集合代码都一样。
隐藏容器内部结构，客户端无需关心存储方式。
遍历与集合解耦，集合变、迭代器变，互不影响。
一个集合可提供多种遍历方式（正序、逆序等）。
符合单一职责：集合存数据，迭代器做遍历。

缺点

每类容器对应一类迭代器，类数量增多。
遍历过程中修改集合可能引发并发异常（fail-fast）。
对于简单集合，略显繁琐。

七、应用场景

统一遍历不同集合：List、Set、Map、树、链表等。
不想暴露集合内部结构，只提供遍历能力。
需要支持多种遍历方式。
框架底层集合设计：几乎所有语言的集合库都用迭代器。

经典应用：

Java Collection 全部迭代器
MyBatis 游标查询 Cursor
Spring Resource 遍历资源
树形结构、图结构的统一遍历

八、迭代器模式 VS 其他模式

迭代器：专注遍历集合元素
责任链：专注按顺序处理请求
组合模式 + 迭代器：天然搭配，遍历树形结构非常常用

九、总结

迭代器模式 = 统一遍历接口 + 隔离集合结构
核心：把遍历逻辑从集合中抽离出来
结构：Aggregate(容器) + Iterator(迭代器)
Java 集合框架就是标准迭代器模式教科书
日常开发不用自己写，直接用 JDK 内置的即可