设计模式系列文章（基础篇第21篇）：迭代器模式——遍历聚合解耦，实现统一迭代访问

大家好，欢迎来到设计模式系列文章（基础篇）的第二十一篇内容。在上一篇中，我们学习了行为型模式的第十种常用模式------观察者模式，其核心是定义对象间的一对多依赖关系，实现发布者与订阅者的解耦，当发布者状态变化时，所有订阅者会自动收到通知并更新，广泛应用于消息通知、数据同步、事件监听等场景，也是框架底层事件驱动的核心思想。今天，我们将学习行为型模式的第十一种常用模式------迭代器模式，它的核心是提供一种统一的方法，顺序访问一个聚合对象（如集合、数组）中的所有元素，而无需暴露该聚合对象的内部表示（如底层存储结构、数据类型），将元素的遍历逻辑与聚合对象本身解耦，让遍历逻辑可以独立扩展，广泛应用于集合遍历、数据迭代等场景，更是Java集合框架（如List、Set、Map）的核心设计思想之一。

在日常开发中，我们经常需要遍历各种聚合对象：比如遍历一个List集合中的所有元素、遍历一个数组中的数据、遍历一个自定义的商品列表。如果不使用迭代器模式，我们需要在聚合对象内部编写遍历逻辑，或者在客户端中直接操作聚合对象的内部结构------比如直接访问List的下标、数组的索引，这种方式会导致客户端与聚合对象强耦合：客户端必须了解聚合对象的内部存储结构（是数组、链表还是其他），才能完成遍历；如果聚合对象的内部结构发生变化（比如从数组改为链表），客户端的遍历代码也必须随之修改，违背开闭原则；同时，不同聚合对象的遍历逻辑分散在各个聚合类中，代码冗余且难以维护。

而迭代器模式，通过引入一个迭代器对象，将遍历逻辑从聚合对象中分离出来，聚合对象只负责存储数据，迭代器负责提供统一的遍历方法（如获取下一个元素、判断是否还有元素）。客户端只需通过迭代器访问聚合对象的元素，无需关心聚合对象的内部结构，也无需编写具体的遍历逻辑；新增聚合对象或修改遍历逻辑时，只需新增对应的迭代器，无需改动客户端和其他聚合对象，完美实现遍历与聚合的解耦。今天，我们就从核心定义、结构、实战实现、场景对比、避坑指南全维度讲解，帮大家彻底掌握这种"统一遍历、解耦聚合"的实用设计模式。

一、迭代器模式的核心定义与设计初衷

1. 核心定义

迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。迭代器模式又称游标模式（Cursor Pattern），核心是分离聚合对象与遍历逻辑，提供统一的迭代访问接口。

通俗理解：迭代器模式就像我们生活中的图书管理员。图书馆（聚合对象）负责存储图书（元素），图书管理员（迭代器）负责带领读者（客户端）顺序浏览图书馆中的所有图书，读者无需知道图书馆的图书是如何分类、如何存储的（内部结构），只需跟随图书管理员，就能依次看到每一本图书。图书管理员提供了统一的"浏览"方法（比如"下一本""是否还有图书"），无论图书馆的存储方式如何变化（比如从书架改为密集架），只要图书管理员的浏览方法不变，读者就无需改变自己的浏览方式，实现了读者与图书馆的解耦。

2. 设计初衷（解决的核心问题）

迭代器模式的出现，核心是解决"聚合对象与遍历逻辑耦合、遍历方式不统一"的痛点，具体解决3个核心问题：

解耦聚合与遍历：将遍历逻辑从聚合对象中分离出来，聚合对象只负责存储数据，迭代器负责遍历，客户端无需关心聚合对象的内部结构；
提供统一遍历接口：定义统一的迭代器接口，无论聚合对象的底层存储结构如何（数组、链表、集合），客户端都能通过相同的方法遍历元素，提升代码一致性；
支持多种遍历方式：针对同一个聚合对象，可以提供不同的迭代器（如正向遍历、反向遍历），新增遍历方式时无需修改聚合对象，符合开闭原则。

3. 设计原则适配

迭代器模式作为经典行为型模式，严格贴合面向对象设计核心原则，是实现聚合与遍历解耦的最佳实践：

单一职责原则：聚合对象只负责存储数据，迭代器只负责遍历数据，职责单一，便于维护和扩展；
开闭原则：新增聚合对象时，只需实现对应的迭代器；新增遍历方式时，只需新增迭代器类，无需修改客户端和现有聚合对象；
迪米特法则（最少知道原则）：客户端只需知道迭代器接口，无需知道聚合对象的内部结构和迭代器的具体实现，减少对象间的交互细节；
依赖倒转原则：客户端依赖迭代器抽象接口，不依赖具体迭代器实现；聚合对象依赖迭代器抽象接口，便于替换不同的迭代器。

二、迭代器模式的核心结构（4个核心角色）

迭代器模式的结构清晰，核心包含4个角色，各司其职、协同完成聚合对象的遍历，我们以"自定义商品列表"为场景，逐一拆解角色职责与交互逻辑：

1. 抽象迭代器（Iterator）

迭代器模式的核心接口，定义了统一的遍历方法，用于访问聚合对象中的元素，通常包含以下4个核心方法：

hasNext()：判断聚合对象中是否还有下一个元素，返回布尔值；
next()：获取聚合对象中的下一个元素；
remove()（可选）：删除当前遍历到的元素；
reset()（可选）：重置迭代器，回到遍历的起始位置。
抽象迭代器屏蔽了具体迭代器的实现细节，让客户端只需依赖抽象接口，就能完成遍历操作。对应商品列表场景中的"商品迭代器接口"，定义遍历商品的通用方法。

2. 具体迭代器（Concrete Iterator）

实现抽象迭代器接口，持有聚合对象的引用，维护当前遍历的位置（游标），实现具体的遍历逻辑。具体迭代器负责跟踪遍历进度，根据聚合对象的内部结构，实现hasNext()、next()等方法，完成元素的顺序访问。对应商品列表场景中的"商品具体迭代器"，根据商品列表的存储结构（如数组），实现商品的遍历。

3. 抽象聚合（Aggregate）

所有具体聚合对象的抽象父类或接口，定义了创建对应迭代器对象的方法（如createIterator()），同时提供维护聚合元素的通用方法（如添加元素、删除元素）。抽象聚合屏蔽了具体聚合的实现细节，让客户端只需依赖抽象聚合，就能创建迭代器并遍历元素。对应商品列表场景中的"商品聚合接口"，定义创建商品迭代器、管理商品的方法。

4. 具体聚合（Concrete Aggregate）

实现抽象聚合接口，维护聚合对象的内部数据（如数组、链表），实现创建具体迭代器的方法------返回与自身存储结构匹配的具体迭代器对象。具体聚合是元素的存储载体，负责存储数据，不负责遍历逻辑，遍历逻辑委托给具体迭代器。对应商品列表场景中的"具体商品列表"，存储商品数据，创建商品迭代器。

核心关系总结：抽象聚合定义聚合规范，具体聚合实现数据存储并创建具体迭代器；抽象迭代器定义遍历规范，具体迭代器实现遍历逻辑并访问具体聚合的元素。客户端通过抽象聚合创建抽象迭代器，再通过抽象迭代器遍历具体聚合中的元素，全程无需关心具体聚合和具体迭代器的实现，实现了解耦。

三、迭代器模式的核心逻辑与执行流程

迭代器模式的核心逻辑是"分离聚合与遍历、统一迭代接口"，标准执行流程分为五步，全程无客户端与聚合对象直接耦合，逻辑闭环：

定义抽象迭代器接口：声明hasNext()、next()等统一的遍历方法；
定义抽象聚合接口：声明创建迭代器的方法和维护元素的通用方法；
实现具体聚合类：维护内部数据结构，实现创建具体迭代器的方法；
实现具体迭代器类：持有具体聚合的引用，维护遍历游标，实现抽象迭代器的所有方法；
客户端初始化：创建具体聚合对象，添加元素，通过具体聚合创建具体迭代器，使用迭代器的遍历方法，顺序访问聚合中的所有元素。
关键要点：具体聚合只负责存储数据，不包含任何遍历逻辑；具体迭代器依赖具体聚合的内部结构，但客户端无需关心这种依赖；客户端通过统一的迭代器接口遍历元素，无论聚合对象的内部结构如何变化，客户端代码无需修改。

四、迭代器模式的实战实现（自定义商品列表场景）

我们以高频的自定义商品列表为场景，使用Java代码实现迭代器模式，模拟商品列表（具体聚合）存储商品数据，通过商品迭代器（具体迭代器）顺序遍历商品，客户端无需关心商品列表的内部存储结构（数组），只需通过迭代器即可访问所有商品，直观体现迭代器模式解耦聚合与遍历、统一迭代接口的核心优势。

场景说明：自定义商品列表（具体聚合）使用数组存储商品数据，支持添加商品、删除商品；商品迭代器（具体迭代器）实现正向遍历商品的功能，支持判断是否有下一个商品、获取下一个商品；客户端通过迭代器遍历商品列表，无需直接操作数组。

1. 第一步：定义商品实体类（聚合元素）

bash 复制代码

// 商品实体类（聚合对象中的元素）
public class Product {
    // 商品ID
    private String productId;
    // 商品名称
    private String productName;
    // 商品价格
    private double price;

    // 构造方法
    public Product(String productId, String productName, double price) {
        this.productId = productId;
        this.productName = productName;
        this.price = price;
    }

    // getter方法（便于迭代器获取商品信息）
    public String getProductId() {
        return productId;
    }

    public String getProductName() {
        return productName;
    }

    public double getPrice() {
        return price;
    }

    // 重写toString方法，便于打印商品信息
    @Override
    public String toString() {
        return "Product{" +
                "productId='" + productId + '\'' +
                ", productName='" + productName + '\'' +
                ", price=" + price +
                '}';
    }
}

2. 第二步：定义抽象迭代器接口（Iterator）

bash 复制代码

// 抽象迭代器：商品迭代器接口
public interface Iterator {
    // 判断是否还有下一个商品
    boolean hasNext();
    // 获取下一个商品
    Product next();
    // 可选：删除当前遍历到的商品
    void remove();
}

3. 第三步：定义抽象聚合接口（Aggregate）

bash 复制代码

// 抽象聚合：商品聚合接口
public interface Aggregate {
    // 创建迭代器对象
    Iterator createIterator();
    // 添加商品
    void addProduct(Product product);
    // 删除商品
    void removeProduct(Product product);
    // 获取商品数量
    int getSize();
}

4. 第四步：实现具体聚合类（ProductList）

bash 复制代码

// 具体聚合：自定义商品列表（使用数组存储商品）
public class ProductList implements Aggregate {
    // 内部存储结构：数组
    private Product[] products;
    // 商品数量（当前实际存储的商品个数）
    private int size = 0;
    // 数组初始容量
    private static final int INIT_CAPACITY = 10;

    // 构造方法：初始化数组
    public ProductList() {
        products = new Product[INIT_CAPACITY];
    }

    @Override
    public Iterator createIterator() {
        // 返回与当前聚合匹配的具体迭代器
        return new ProductIterator(this);
    }

    @Override
    public void addProduct(Product product) {
        // 数组扩容（简单实现）
        if (size >= products.length) {
            Product[] newProducts = new Product[products.length * 2];
            System.arraycopy(products, 0, newProducts, 0, products.length);
            products = newProducts;
        }
        products[size++] = product;
    }

    @Override
    public void removeProduct(Product product) {
        // 遍历数组，删除指定商品
        for (int i = 0; i < size; i++) {
            if (products[i].equals(product)) {
                // 移动数组元素，覆盖被删除的商品
                System.arraycopy(products, i + 1, products, i, size - i - 1);
                size--;
                break;
            }
        }
    }

    @Override
    public int getSize() {
        return size;
    }

    // 提供方法，供迭代器访问内部数组（仅暴露必要的访问方式，不暴露完整数组）
    public Product getProduct(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界");
        }
        return products[index];
    }
}

5. 第五步：实现具体迭代器类（ProductIterator）

bash 复制代码

// 具体迭代器：商品迭代器（正向遍历）
public class ProductIterator implements Iterator {
    // 持有具体聚合的引用，用于访问聚合中的元素
    private ProductList productList;
    // 遍历游标：记录当前遍历到的索引位置
    private int index = 0;

    // 构造方法：传入具体聚合对象
    public ProductIterator(ProductList productList) {
        this.productList = productList;
    }

    @Override
    public boolean hasNext() {
        // 判断游标是否小于商品数量，若小于则还有下一个元素
        return index < productList.getSize();
    }

    @Override
    public Product next() {
        // 获取当前游标位置的商品，并将游标向后移动一位
        if (hasNext()) {
            return productList.getProduct(index++);
        }
        throw new NoSuchElementException("没有更多商品了");
    }

    @Override
    public void remove() {
        // 删除当前遍历到的商品（游标需回退一位，避免跳过下一个元素）
        if (index > 0) {
            productList.removeProduct(productList.getProduct(--index));
        } else {
            throw new IllegalStateException("无法删除未遍历的元素");
        }
    }
}

6. 第六步：客户端测试

bash 复制代码

// 客户端测试：自定义商品列表遍历场景
public class IteratorPatternTest {
    public static void main(String[] args) {
        // 1. 创建具体聚合对象（商品列表）
        Aggregate productList = new ProductList();

        // 2. 向商品列表添加商品
        productList.addProduct(new Product("P001", "Java编程思想", 89.9));
        productList.addProduct(new Product("P002", "设计模式详解", 69.9));
        productList.addProduct(new Product("P003", "SpringBoot实战", 79.9));
        productList.addProduct(new Product("P004", "MySQL从入门到精通", 59.9));

        // 3. 创建迭代器对象
        Iterator iterator = productList.createIterator();

        // 4. 使用迭代器遍历商品列表
        System.out.println("=== 正向遍历所有商品 ===");
        while (iterator.hasNext()) {
            Product product = iterator.next();
            System.out.println(product);
        }

        // 5. 重置迭代器，测试删除功能
        iterator = productList.createIterator(); // 重新创建迭代器，重置游标
        System.out.println("\n=== 遍历并删除指定商品 ===");
        while (iterator.hasNext()) {
            Product product = iterator.next();
            if ("P002".equals(product.getProductId())) {
                iterator.remove();
                System.out.println("已删除商品：" + product);
                break;
            }
        }

        // 6. 再次遍历，查看删除后的结果
        System.out.println("\n=== 删除后的商品列表 ===");
        iterator = productList.createIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

运行结果

bash 复制代码

=== 正向遍历所有商品 ===
Product{productId='P001', productName='Java编程思想', price=89.9}
Product{productId='P002', productName='设计模式详解', price=69.9}
Product{productId='P003', productName='SpringBoot实战', price=79.9}
Product{productId='P004', productName='MySQL从入门到精通', price=59.9}

=== 遍历并删除指定商品 ===
已删除商品：Product{productId='P002', productName='设计模式详解', price=69.9}

=== 删除后的商品列表 ===
Product{productId='P001', productName='Java编程思想', price=89.9}
Product{productId='P003', productName='SpringBoot实战', price=79.9}
Product{productId='P004', productName='MySQL从入门到精通', price=59.9}

从运行结果可以看出，客户端通过迭代器接口，无需关心商品列表的内部存储结构（数组），就能完成商品的遍历和删除操作；当商品列表的内部存储结构发生变化（比如从数组改为链表）时，只需修改具体聚合和具体迭代器的实现，客户端代码无需任何改动，完美体现了迭代器模式解耦聚合与遍历的核心优势。

五、迭代器模式的高频应用场景

迭代器模式适用于所有需要遍历聚合对象、且需要解耦聚合与遍历逻辑的业务场景，核心作用是统一遍历接口、分离遍历逻辑，以下是四大高频落地场景：

1. 集合框架遍历（最经典应用）

主流编程语言的集合框架，几乎都使用了迭代器模式，提供统一的遍历接口，屏蔽不同集合的内部存储差异：

Java集合框架：List、Set、Map等集合，都提供了Iterator迭代器，客户端通过Iterator的hasNext()、next()方法，就能统一遍历不同集合的元素，无需关心集合的内部结构（ArrayList是数组、LinkedList是链表）；
Python集合：list、tuple、dict等集合，通过for-in循环遍历，底层本质是迭代器模式，隐藏了遍历逻辑；
C#集合：ICollection接口提供GetEnumerator()方法，返回迭代器，实现统一遍历。

2. 自定义聚合对象遍历

开发中自定义的聚合对象（如商品列表、用户列表、订单列表），需要提供遍历功能时，使用迭代器模式分离遍历逻辑，提升代码可维护性：

自定义数据结构：如自定义链表、栈、队列等，通过迭代器提供统一的遍历方法；
业务聚合对象：如电商系统的商品列表、订单列表，后台管理系统的用户列表，通过迭代器实现灵活遍历，支持正向、反向等多种遍历方式。

3. 多遍历方式场景

同一个聚合对象需要支持多种遍历方式（如正向遍历、反向遍历、按条件遍历）时，使用迭代器模式，每种遍历方式对应一个具体迭代器，互不干扰：

列表遍历：支持正向遍历、反向遍历，分别对应正向迭代器、反向迭代器；
数据筛选遍历：支持按条件筛选遍历（如遍历价格大于100的商品），对应筛选迭代器；
分页遍历：支持分页遍历聚合对象中的元素，对应分页迭代器。

4. 框架底层与工具类设计

主流开源框架和工具类中，大量使用迭代器模式实现数据遍历与解耦，是框架灵活性的重要保障：

MyBatis：查询结果集（ResultSet）的遍历，底层使用迭代器模式，提供统一的遍历接口，屏蔽数据库查询结果的底层实现；
Spring：Spring Data JPA的分页查询结果，通过PageIterator实现分页遍历，解耦分页逻辑与数据存储；
Apache Commons Collections：提供了多种迭代器实现（如过滤迭代器、反转迭代器），扩展了集合的遍历功能。

六、迭代器模式 vs 其他相似模式（重点区分）

迭代器模式常与组合模式、工厂方法模式混淆，三者都涉及对象的访问与创建，但核心目标、使用场景完全不同，通过表格清晰对比，帮大家快速区分：

对比维度	迭代器模式	组合模式	工厂方法模式
核心目标	分离聚合与遍历逻辑，提供统一的迭代访问接口	将对象组合成树形结构，统一访问单个对象和组合对象	定义创建对象的接口，让子类决定实例化哪个类
核心逻辑	通过迭代器遍历聚合对象的元素，不暴露内部结构	将对象组合成树形结构，递归访问所有子对象	通过工厂方法创建对象，解耦对象创建与使用
适用场景	聚合对象遍历、统一遍历接口（关注"遍历"）	树形结构对象访问、整体与部分统一处理（关注"组合"）	对象创建、解耦创建与使用（关注"创建"）
核心角色	抽象迭代器、具体迭代器、抽象聚合、具体聚合	抽象组件、具体组件、抽象组合、具体组合	抽象工厂、具体工厂、抽象产品、具体产品

一句话总结：迭代器模式管"遍历"，组合模式管"组合"，工厂方法模式管"创建"；需要遍历聚合对象用迭代器模式，需要组合树形结构对象用组合模式，需要解耦对象创建用工厂方法模式，三者可结合使用（如组合模式+迭代器模式，遍历树形结构中的所有元素）。

七、迭代器模式的常见坑与避坑指南

坑1：迭代器遍历过程中，直接修改聚合对象，导致遍历异常

在使用迭代器遍历聚合对象时，如果直接通过聚合对象的方法添加、删除元素（而非迭代器的remove()方法），会导致迭代器的游标与聚合对象的实际状态不一致，引发ConcurrentModificationException（并发修改异常）。

避坑指南：遍历过程中，若需修改聚合对象（添加、删除元素），必须使用迭代器自身的remove()方法（或对应修改方法）；若需批量修改，可先记录需要修改的元素，遍历结束后再统一修改。

坑2：过度设计，简单聚合无需使用迭代器模式

部分开发者在简单聚合场景中（如仅遍历一个简单数组、单个集合），强行使用迭代器模式，新增抽象迭代器、具体迭代器、抽象聚合等角色，导致代码冗余、逻辑复杂化，违背设计模式初衷。

避坑指南：只有当聚合对象需要被多次遍历、需要支持多种遍历方式、或需要解耦聚合与遍历逻辑时，才使用迭代器模式；简单聚合场景（如单次遍历、内部结构固定），直接使用普通循环遍历即可，无需过度设计。

坑3：迭代器与聚合对象强耦合，难以扩展

部分开发者在实现时，让具体迭代器直接依赖具体聚合的内部细节（如直接操作聚合的私有数组），导致聚合对象的内部结构变化时，迭代器也必须随之修改，耦合过高。

避坑指南：具体迭代器通过抽象聚合接口访问聚合对象的元素，不直接操作聚合的私有成员；聚合对象提供统一的元素访问方法（如getProduct(int index)），供迭代器调用，降低耦合。

坑4：忽略迭代器的边界判断，导致异常

部分开发者在实现迭代器的next()方法时，未判断边界（即没有元素时仍调用next()），导致NoSuchElementException异常；或hasNext()方法实现错误，导致遍历遗漏或重复元素。

避坑指南：严格实现hasNext()方法，确保准确判断是否还有下一个元素；在next()方法中，先调用hasNext()判断，若没有元素则抛出明确的异常，避免边界错误。

坑5：未提供重置迭代器的方法，导致无法重复遍历

部分迭代器实现中，未提供reset()方法，遍历结束后游标无法重置，若需再次遍历聚合对象，只能重新创建迭代器，增加系统开销。

避坑指南：在抽象迭代器中添加reset()方法，实现具体迭代器时，重置游标到初始位置，支持迭代器的重复使用，减少对象创建开销。

八、系列文章预告

本篇文章，我们详细讲解了迭代器模式的核心定义、四大核心角色、标准执行流程、自定义商品列表场景实战代码、高频应用场景和避坑指南，同时区分了易混淆的组合模式、工厂方法模式。迭代器模式凭借"分离聚合与遍历、统一迭代接口"的优势，成为集合遍历、自定义聚合对象遍历场景的首选设计模式，也是主流编程语言集合框架的核心设计思想，能大幅提升代码的一致性与可维护性。

下一篇，我们将学习行为型模式的第十二种常用模式------访问者模式，它的核心是定义一个访问者对象，封装对聚合对象中元素的操作，让操作可以独立于元素的类而变化，将数据结构与数据操作解耦，广泛应用于数据结构固定、操作多变的场景，如报表生成、数据统计、元素解析等。

访问者模式------分离数据结构与操作，实现灵活扩展。我们不见不散！