一句话总结：迭代器模式（Iterator Pattern）让你不暴露集合内部结构，就能遍历集合元素。它是Java集合框架的基石，也是解耦遍历与集合的关键设计模式。

一、先看痛点：为什么需要迭代器？

假设有一个「待办任务列表」用ArrayList和LinkedList两种方式实现：

// ArrayList实现
List<String> arrayTaskList = new ArrayList<>();
arrayTaskList.add("写周报");
arrayTaskList.add("修复Bug");

// LinkedList实现
List<String> linkedTaskList = new LinkedList<>();
linkedTaskList.add("设计新功能");
linkedTaskList.add("代码Review");

问题：

1. 如果遍历时分别调arrayTaskList.get(i)和linkedTaskList.get(i)，性能天差地别（链表随机访问O(n)）。
2. 客户端必须知道集合具体类型，耦合度高。
3. 新增集合类型（如树结构）需重写遍历逻辑。

二、迭代器模式解决方案

核心思想：将遍历行为抽离成独立对象。

1. UML结构

                          ┌─────────────┐
                          │   Iterator  │
                          ├─────────────┤
                          │ hasNext()   │
                          │ next()      │
                          └─────────────┘
                                 ▲
                                 │
          ┌──────────────────────┼──────────────────────┐
          │                      │                      │
┌─────────────────┐    ┌───────────────────┐    ┌─────────────────┐
│  ArrayIterator  │    │  LinkedListIterator│    │   TreeIterator  │
├─────────────────┤    ├───────────────────┤    ├─────────────────┤
│ hasNext()       │    │ hasNext()         │    │ hasNext()       │
│ next()          │    │ next()            │    │ next()          │
└─────────────────┘    └───────────────────┘    └─────────────────┘
          ▲                      ▲                      ▲
          │                      │                      │
┌─────────────────┐    ┌───────────────────┐    ┌─────────────────┐
│    ArrayList    │    │    LinkedList     │    │      Tree       │
├─────────────────┤    ├───────────────────┤    ├─────────────────┤
│ iterator()      │    │ iterator()        │    │ iterator()      │
└─────────────────┘    └───────────────────┘    └─────────────────┘

2. 代码实现

步骤1：定义迭代器接口

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

步骤2：为不同集合实现迭代器

// ArrayList迭代器
public class ArrayIterator<T> implements Iterator<T> {
    private final List<T> list;
    private int index = 0;

    public ArrayIterator(List<T> list) {
        this.list = list;
    }

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

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

// LinkedList迭代器（简化版）
public class LinkedListIterator<T> implements Iterator<T> {
    private Node<T> current;

    public LinkedListIterator(Node<T> head) {
        this.current = head;
    }

    @Override
    public boolean hasNext() {
        return current != null;
    }

    @Override
    public T next() {
        T data = current.data;
        current = current.next;
        return data;
    }
}

步骤3：在集合中返回迭代器

public class MyArrayList<T> {
    private final List<T> list = new ArrayList<>();

    public void add(T item) {
        list.add(item);
    }

    public Iterator<T> iterator() {
        return new ArrayIterator<>(list);
    }
}

public class MyLinkedList<T> {
    private static class Node<T> { /* 节点定义 */ }
    private Node<T> head;

    public void add(T data) { /* 添加节点 */ }

    public Iterator<T> iterator() {
        return new LinkedListIterator<>(head);
    }
}

步骤4：客户端统一遍历

public class Client {
    public static void main(String[] args) {
        MyArrayList<String> tasks1 = new MyArrayList<>();
        tasks1.add("写周报");
        tasks1.add("修复Bug");

        MyLinkedList<String> tasks2 = new MyLinkedList<>();
        tasks2.add("设计新功能");
        tasks2.add("代码Review");

        // 统一遍历方式
        traverse(tasks1.iterator());
        traverse(tasks2.iterator());
    }

    private static void traverse(Iterator<String> iterator) {
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

三、适用场景（什么时候用？）

1. 隐藏集合内部结构

• 客户端无需知道底层是数组、链表还是树。

1. 统一遍历接口

• 对不同集合（如List、Set、Map）使用相同遍历逻辑。

1. 支持并行遍历

• 多个迭代器可独立遍历同一集合（如游戏中的多个NPC寻路）。

1. 简化客户端代码

• 避免在业务逻辑中混入for (int i=0; i<list.size(); i++)这类底层代码。

四、优缺点（为什么用？）

五、Java集合框架的经典应用

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> it = list.iterator(); // 获取迭代器

Set<Integer> set = new HashSet<>(Set.of(1, 2, 3));
Iterator<Integer> setIt = set.iterator(); // 同样接口！

六、终极总结

1. 用迭代器当你有多种集合需要遍历（数组、链表、树、图）。
2. 用迭代器当你想隐藏集合复杂结构（如数据库查询结果集）。
3. 不要用迭代器当集合极其简单（如单个数组直接for循环）。

设计模式本质：

隔离变化点 —— 将易变的集合结构与稳定的遍历行为分离。