行为型：迭代器模式

目录

1、核心思想

2、实现方式

[2.1 模式结构](#2.1 模式结构)

[2.2 实现案例](#2.2 实现案例)

3、优缺点分析

4、适用场景

---

1、核心思想

目的：将遍历逻辑与数据存储结构解耦

概念：提供一种机制来按顺序访问集合中的各元素，而不需要知道集合内部的构造

举例：

1> 书籍目录与翻页：目录是迭代器，读者通过目录按顺序查找内容，无需了解书籍的章节存储方式

2> 音乐播放列表：播放器通过"下一曲"按钮遍历歌曲列表，不关心列表是数组还是链表

2、实现方式

2.1 模式结构

四种核心角色：

• Iterator（迭代器接口）：迭代器的接口标准，定义遍历元素的方法，如next()、hasNext()等。
• ConcreteIterator（迭代器实现）：迭代器接口Iterator的具体实现类，管理遍历的当前位置和逻辑。
• Aggregate（集合接口）：集合标准接口，一种具备迭代能力的指标。
• ConcreteAggregate（集合实现）：实现集合接口Aggregate的具体集合类，可以实例化并返回一个迭代器以供外部使用（如createIterator()）。

2.2 实现案例

以遍历自定义集合为例，实现正向和反向迭代器：

// 迭代器接口
interface Iterator<T> {
    boolean hasNext();
    T next();
}

// 具体聚合类（集合）
class BookCollection {
    private String[] books = {"Java", "Python", "C++"};

    // 创建正向迭代器
    public Iterator<String> createForwardIterator() {
        return new ForwardIterator();
    }

    // 创建反向迭代器
    public Iterator<String> createReverseIterator() {
        return new ReverseIterator();
    }

    // 正向迭代器（私有内部类）
    private class ForwardIterator implements Iterator<String> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < books.length;
        }

        @Override
        public String next() {
            if (hasNext()) {
                return books[index++];
            }
            return null;
        }
    }

    // 反向迭代器（私有内部类）
    private class ReverseIterator implements Iterator<String> {
        private int index = books.length - 1;

        @Override
        public boolean hasNext() {
            return index >= 0;
        }

        @Override
        public String next() {
            if (hasNext()) {
                return books[index--];
            }
            return null;
        }
    }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        BookCollection collection = new BookCollection();

        System.out.println("正向遍历：");
        Iterator<String> forward = collection.createForwardIterator();
        while (forward.hasNext()) {
            System.out.println(forward.next());
        }

        System.out.println("\n反向遍历：");
        Iterator<String> reverse = collection.createReverseIterator();
        while (reverse.hasNext()) {
            System.out.println(reverse.next());
        }
    }
}

关键点：

• 封装遍历细节 ：迭代器内部维护遍历状态（如当前索引），客户端仅调用hasNext()和next()。

• 支持多遍历方式：同一集合可提供多种迭代器（如正向、反向、过滤等）。

3、优缺点分析

优点	缺点
解耦客户端代码与集合结构	增加类的数量（迭代器需单独实现）
支持多种遍历策略	简单集合使用迭代器可能冗余
符合单一职责和开闭原则

4、适用场景

• 集合框架

  • Java的Collection通过Iterator提供遍历能力，如List.iterator()。

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

• 复杂数据结构遍历

  • 树、图等结构的深度优先（DFS）、广度优先（BFS）遍历。

class TreeNode {
    int val;
    TreeNode left, right;
    // 构造方法省略
}

// 中序遍历
class InOrderIterator implements Iterator<TreeNode> {
    private Stack<TreeNode> stack = new Stack<>();

    public InOrderIterator(TreeNode root) {
        pushLeft(root);
    }

    private void pushLeft(TreeNode node) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
    }

    @Override
    public boolean hasNext() {
        return !stack.isEmpty();
    }

    @Override
    public TreeNode next() {
        TreeNode node = stack.pop();
        pushLeft(node.right); // 处理右子树
        return node;
    }
}

// 使用示例
TreeNode root = buildTree(); // 构建二叉树
Iterator<TreeNode> it = new InOrderIterator(root);
while (it.hasNext()) {
    System.out.println(it.next().val);
}

• 数据库查询结果处理

  • 遍历查询结果集（如JDBC的ResultSet）。

• 文件系统遍历

  • 递归遍历目录中的文件。

• 分页加载数据

  • 分批加载大数据集（如社交媒体的动态流）。