迭代器模式 (Iterator Pattern)

迭代器模式是一种 行为型设计模式，用于顺序访问集合对象中的元素，而无需暴露集合的内部表示。它提供了一种统一的方式来遍历不同类型的集合。

原理

1. 核心思想：
   • 将集合的遍历逻辑封装在迭代器对象中，分离集合对象的存储和迭代行为。
2. 适用场景：
   • 需要访问集合对象中的内容，而不希望暴露其内部结构。
   • 需要以不同方式遍历集合。
   • 提供一个统一接口，支持多种类型集合的迭代。
3. 参与角色：
   • Iterator（迭代器接口）：
     • 定义访问和遍历元素的方法。
   • ConcreteIterator（具体迭代器）：
     • 实现迭代器接口，负责具体的遍历行为。
   • Aggregate（集合接口）：
     • 定义创建迭代器的接口。
   • ConcreteAggregate（具体集合）：
     • 实现集合接口，并返回具体的迭代器。

优点

1. 单一职责原则：
   • 集合类负责存储数据，迭代器负责遍历，分离了职责。
2. 开放/封闭原则：
   • 可以新增不同的迭代方式，而无需修改集合类。
3. 统一接口：
   • 不同集合的遍历方式对外统一。

缺点

1. 开销：
   • 如果集合很大，创建多个迭代器对象可能会增加内存开销。
2. 访问限制：
   • 某些高级操作（如随机访问）可能不适用于简单迭代器。

示例代码

场景描述

设计一个自定义集合类 CustomCollection，并提供一个迭代器来遍历其中的元素。

1. 定义迭代器接口

// 迭代器接口
public interface Iterator<T> {
    boolean hasNext();  // 是否还有下一个元素
    T next();           // 获取下一个元素
}

2. 定义集合接口

// 集合接口
public interface Aggregate<T> {
    Iterator<T> createIterator();  // 创建迭代器
}

3. 实现具体集合类

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

// 具体集合类
public class CustomCollection<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<>();

    // 添加元素
    public void add(T item) {
        items.add(item);
    }

    // 获取元素
    public T get(int index) {
        return items.get(index);
    }

    // 获取集合大小
    public int size() {
        return items.size();
    }

    // 创建迭代器
    @Override
    public Iterator<T> createIterator() {
        return new CustomIterator();
    }

    // 具体迭代器类
    private class CustomIterator implements Iterator<T> {
        private int index = 0; // 当前索引

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

        @Override
        public T next() {
            return items.get(index++);
        }
    }
}

4. 客户端代码

public class IteratorPatternExample {
    public static void main(String[] args) {
        // 创建集合
        CustomCollection<String> collection = new CustomCollection<>();
        collection.add("Element 1");
        collection.add("Element 2");
        collection.add("Element 3");

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

        // 使用迭代器遍历集合
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

输出结果

Element 1
Element 2
Element 3

UML 类图

        +----------------+
        |   Aggregate    |<-----------------+
        +----------------+                  |
        | + createIterator(): Iterator<T>   |
        +----------------+                  |
                ^                           |
                |                           |
  +---------------------------+     +-------------------+
  |   CustomCollection<T>     |     |    Iterator<T>    |
  +---------------------------+     +-------------------+
  | - items : List<T>         |     | + hasNext(): bool |
  | + add(item): void         |     | + next(): T       |
  | + createIterator(): CustomIterator<T> |
  +---------------------------+     +-------------------+
                ^                           ^
                |                           |
  +---------------------------+     +-------------------+
  |   CustomIterator<T>       |     |       Client      |
  +---------------------------+     +-------------------+
  | - index : int             |     
  | + hasNext(): bool         |
  | + next(): T               |
  +---------------------------+

使用场景

1. 集合类的封装：
   • 如 Java 中的 ArrayList, HashMap 的迭代器。
2. 多种遍历方式：
   • 深度优先搜索和广度优先搜索可以使用不同的迭代器实现。
3. 复杂对象的遍历：
   • 需要以特定顺序访问复杂结构中的数据。

优化与扩展

1. 支持多种遍历方式：
   • 如反向迭代器、跳步迭代器等。
2. 线程安全：
   • 提供线程安全的迭代器（如 CopyOnWriteArrayList 的迭代器）。
3. 懒加载：
   • 对于大集合，可以使用惰性迭代器按需加载数据。

小结

• 迭代器模式使得集合的遍历行为与集合内部结构解耦。
• 提供了统一的访问方式，但实现迭代器可能带来一定的额外开销。
• 在实际开发中，迭代器模式广泛应用于各种集合类的遍历操作，尤其是在框架设计中非常常见。