设计模式之迭代器模式：遍历的艺术与实现-EW帮帮网

引言

迭代器模式（Iterator Pattern）是一种行为型设计模式，它提供了一种顺序访问聚合对象中各个元素的方法，而又不暴露其底层实现。迭代器模式将遍历逻辑与聚合对象解耦，使得我们可以用统一的方式处理不同的集合结构。本文将深入探讨迭代器模式的原理、实现方式以及实际应用场景，帮助你掌握这种优雅的遍历机制。

1. 迭代器模式的核心概念

1.1 什么是迭代器模式？

迭代器模式是一种行为型设计模式，它通过提供统一的接口来顺序访问聚合对象中的元素，而不需要了解底层数据结构的具体实现。

1.2 迭代器模式的应用场景

统一遍历接口：需要为不同类型的集合提供统一的遍历方式
隐藏集合实现：不希望暴露集合内部结构给客户端
支持多种遍历：需要同时支持多种遍历方式（如前序、中序、后序）

2. 迭代器模式的实现方式

2.1 基本结构

迭代器模式通常包含以下几个角色：

迭代器接口（Iterator）：定义遍历集合的接口
具体迭代器（ConcreteIterator）：实现迭代器接口
聚合接口（Aggregate）：定义创建迭代器的接口
具体聚合类（ConcreteAggregate）：实现聚合接口

2.2 代码示例

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

// 聚合接口
public interface Aggregate<T> {
    Iterator<T> createIterator();
}

// 具体聚合类
public class BookCollection implements Aggregate<String> {
    private String[] books = {"Design Patterns", "Clean Code", "Refactoring"};

    @Override
    public Iterator<String> createIterator() {
        return new BookIterator();
    }

    // 具体迭代器（内部类）
    private class BookIterator implements Iterator<String> {
        private int index = 0;

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Aggregate<String> collection = new BookCollection();
        Iterator<String> iterator = collection.createIterator();
        
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

3. 迭代器模式的最佳实践

3.1 封装遍历逻辑

单一职责：将遍历逻辑从集合类中分离出来
简化集合接口：保持集合接口的简洁性

3.2 支持多种遍历方式

前序/后序遍历：通过不同的迭代器实现
过滤迭代器：实现带过滤条件的遍历

3.3 线程安全考虑

快速失败机制：检测并发修改
不可变迭代器：返回集合的快照

4. 迭代器模式的实际应用

4.1 树形结构遍历

// 二叉树节点
class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;
    
    // 中序迭代器
    public Iterator<Integer> inOrderIterator() {
        return new InOrderIterator(this);
    }
    
    private static class InOrderIterator implements Iterator<Integer> {
        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 Integer next() {
            TreeNode node = stack.pop();
            pushLeft(node.right);
            return node.value;
        }
    }
}

4.2 文件系统遍历

// 文件系统迭代器
public class FileSystemIterator implements Iterator<File> {
    private Queue<File> queue = new LinkedList<>();
    
    public FileSystemIterator(File root) {
        queue.offer(root);
    }
    
    @Override
    public boolean hasNext() {
        return !queue.isEmpty();
    }
    
    @Override
    public File next() {
        File current = queue.poll();
        if (current.isDirectory()) {
            File[] children = current.listFiles();
            if (children != null) {
                for (File child : children) {
                    queue.offer(child);
                }
            }
        }
        return current;
    }
}

4.3 数据库结果集遍历

// 数据库结果集迭代器
public class ResultSetIterator implements Iterator<Map<String, Object>> {
    private ResultSet rs;
    private boolean hasNext;
    
    public ResultSetIterator(ResultSet rs) throws SQLException {
        this.rs = rs;
        this.hasNext = rs.next();
    }
    
    @Override
    public boolean hasNext() {
        return hasNext;
    }
    
    @Override
    public Map<String, Object> next() {
        try {
            Map<String, Object> row = new HashMap<>();
            ResultSetMetaData meta = rs.getMetaData();
            for (int i = 1; i <= meta.getColumnCount(); i++) {
                row.put(meta.getColumnName(i), rs.getObject(i));
            }
            hasNext = rs.next();
            return row;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

5. 迭代器模式的优缺点

5.1 优点

解耦集合与遍历逻辑
支持多种遍历方式
简化集合接口
可以暂停遍历过程

5.2 缺点

简单集合可能过度设计
性能开销（某些实现）
可能破坏封装（如果迭代器修改集合）

结语

迭代器模式是处理集合遍历的优雅解决方案，它通过将遍历逻辑抽象出来，使得我们可以用统一的方式处理各种数据结构。掌握迭代器模式不仅能让你写出更清晰的代码，还能更好地理解Java集合框架的设计思想。希望本文能帮助你深入理解这一重要的设计模式！

如果你需要了解特定语言的实现细节或有其他相关问题，欢迎随时提问！

设计模式之迭代器模式：遍历的艺术与实现

引言