Java行为型模式---迭代器模式

迭代器模式基础概念

迭代器模式（Iterator Pattern）是一种行为型设计模式，其核心思想是提供一种方法顺序访问聚合对象（如集合、列表等）中的元素，而无需暴露该对象的内部表示。迭代器模式将遍历逻辑与聚合对象分离，使聚合对象的结构和遍历算法可以独立变化。

迭代器模式的核心组件

1. 迭代器接口（Iterator） - 定义访问和遍历元素的接口，包含hasNext()（是否有下一个元素）和next()（获取下一个元素）等方法。
2. 具体迭代器（ConcreteIterator） - 实现迭代器接口，负责跟踪当前遍历位置，完成具体的遍历逻辑。
3. 聚合接口（Aggregate） - 定义创建迭代器对象的接口，通常包含createIterator()方法。
4. 具体聚合（ConcreteAggregate） - 实现聚合接口，返回具体迭代器的实例，同时存储和管理元素。
5. 客户端（Client） - 通过聚合接口获取迭代器，再使用迭代器遍历元素，无需关心聚合对象的内部结构。

迭代器模式的实现

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

// 1. 迭代器接口
interface Iterator {
    boolean hasNext();
    Object next();
}

// 2. 聚合接口
interface Aggregate {
    Iterator createIterator();
}

// 3. 具体迭代器（遍历自定义列表）
class ConcreteIterator implements Iterator {
    private final List<String> items;  // 聚合对象的元素
    private int position = 0;          // 当前遍历位置

    public ConcreteIterator(List<String> items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        // 判断是否还有下一个元素
        return position < items.size();
    }

    @Override
    public Object next() {
        // 返回当前元素并移动到下一个位置
        if (this.hasNext()) {
            return items.get(position++);
        }
        return null;
    }
}

// 4. 具体聚合（自定义列表）
class ConcreteAggregate implements Aggregate {
    private final List<String> items = new ArrayList<>();

    public void addItem(String item) {
        items.add(item);
    }

    public void removeItem(String item) {
        items.remove(item);
    }

    @Override
    public Iterator createIterator() {
        // 返回迭代器实例，关联当前聚合对象的元素
        return new ConcreteIterator(items);
    }
}

// 5. 客户端代码
public class IteratorPatternClient {
    public static void main(String[] args) {
        // 创建聚合对象并添加元素
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.addItem("Item 1");
        aggregate.addItem("Item 2");
        aggregate.addItem("Item 3");
        aggregate.addItem("Item 4");

        // 获取迭代器并遍历元素
        Iterator iterator = aggregate.createIterator();
        System.out.println("遍历聚合对象元素：");
        while (iterator.hasNext()) {
            String item = (String) iterator.next();
            System.out.println(item);
        }
    }
}

Java 内置迭代器的应用

Java 集合框架（java.util）广泛使用了迭代器模式，Iterator接口是迭代器模式的典型实现。以下是 Java 内置迭代器的使用示例：

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

public class JavaIteratorExample {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // 获取迭代器
        Iterator<String> iterator = fruits.iterator();

        // 遍历元素
        System.out.println("Java内置迭代器遍历：");
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);
            
            // 迭代过程中可以安全删除元素
            if (fruit.equals("Banana")) {
                iterator.remove();
            }
        }

        System.out.println("删除后的列表：" + fruits);  // [Apple, Orange]
    }
}

Java 迭代器的核心方法：

• hasNext()：判断是否有下一个元素
• next()：返回当前元素并移动到下一个位置
• remove()：删除next()返回的最后一个元素（可选操作）

迭代器模式的应用场景

1. 聚合对象遍历 - 如列表、集合、树等复杂数据结构的遍历
2. 隐藏内部结构 - 不希望暴露聚合对象的内部实现（如数组、链表等）
3. 多种遍历方式 - 一个聚合对象需要支持多种遍历方式（如正序、倒序、过滤遍历）
4. 统一遍历接口 - 对不同类型的聚合对象（如数组、链表、哈希表）提供统一的遍历接口
5. 迭代中操作安全 - 需要在遍历过程中安全地添加 / 删除元素（如 Java 迭代器的remove()方法）

迭代器模式的优缺点

优点：

• 解耦遍历与聚合 - 遍历逻辑与聚合对象分离，各自可独立变化
• 统一遍历接口 - 不同聚合对象可以通过相同的迭代器接口遍历
• 支持多种遍历方式 - 一个聚合对象可以有多个迭代器实现不同的遍历逻辑
• 简化客户端代码 - 客户端无需了解聚合对象的内部结构即可遍历
• 符合单一职责原则 - 聚合对象负责存储数据，迭代器负责遍历数据

缺点：

• 类数量增加 - 每个聚合对象可能需要对应一个迭代器，增加系统复杂度
• 遍历效率问题 - 某些迭代器（如链表的随机访问迭代器）可能效率较低
• 迭代器状态依赖 - 迭代器依赖聚合对象的状态，聚合对象修改可能导致迭代器失效
• 双向迭代复杂 - 实现双向迭代器（支持previous()）会增加设计难度

迭代器模式的扩展

1. 双向迭代器（Bidirectional Iterator） - 支持向前和向后遍历（如ListIterator）：

   interface BidirectionalIterator extends Iterator {
       boolean hasPrevious();
       Object previous();
   }
   

2. 跳跃迭代器（Jump Iterator） - 支持跳过部分元素（如间隔 n 个元素遍历）：

   interface JumpIterator extends Iterator {
       Object jump(int steps);  // 跳过steps个元素
   }
   

3. 过滤迭代器（Filter Iterator） - 只遍历符合条件的元素：

   class FilterIterator implements Iterator {
       private final Iterator iterator;
       private final Predicate filter;  // 过滤条件
       
       // 实现略...
   }
   

使用迭代器模式的注意事项

1. 迭代器的线程安全 - 多线程环境下，迭代器需要考虑线程安全（如使用同步或并发迭代器）
2. 避免迭代中修改聚合对象 - 多数迭代器不支持遍历中修改聚合对象（会抛出ConcurrentModificationException）
3. 合理设计迭代器生命周期 - 迭代器应与聚合对象的生命周期匹配，避免无效引用
4. 优先使用内置迭代器 - Java 集合框架已实现完善的迭代器，无需重复造轮子
5. 结合 foreach 循环 - Java 5 + 的增强 for 循环（foreach）本质上是迭代器的语法糖，可简化代码

总结

迭代器模式通过分离聚合对象的存储逻辑和遍历逻辑，实现了代码的解耦和复用。它在 Java 集合框架中应用广泛，是处理集合遍历的标准方式。合理使用迭代器模式可以简化客户端代码，隐藏聚合对象的内部结构，并支持灵活的遍历方式。在实际开发中，除非需要自定义聚合结构或特殊遍历逻辑，否则优先使用 Java 内置的Iterator接口及其实现。