设计模式：迭代器模式

迭代器模式的示例可以涵盖各种数据结构的遍历，包括数组、列表、树、图等。下面是一些不同场景下迭代器模式的示例及其代码实现。

示例 1: 数组遍历

使用迭代器模式遍历数组。

java 复制代码

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

// 数组迭代器
class ArrayIterator<T> implements Iterator<T> {
    private T[] array;
    private int currentIndex = 0;

    public ArrayIterator(T[] array) {
        this.array = array;
    }

    @Override
    public boolean hasNext() {
        return currentIndex < array.length;
    }

    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return array[currentIndex++];
    }
}

// 客户端代码
public class ArrayIteratorExample {
    public static void main(String[] args) {
        Integer[] numbers = {1, 2, 3, 4, 5};
        Iterator<Integer> iterator = new ArrayIterator<>(numbers);

        while (iterator.hasNext()) {
            Integer number = iterator.next();
            System.out.println(number);
        }
    }
}

示例 2: 二叉树的深度优先遍历

二叉树的深度优先遍历（使用栈实现）。

java 复制代码

// 树节点
class TreeNode<T> {
    T value;
    TreeNode<T> left;
    TreeNode<T> right;

    TreeNode(T value) {
        this.value = value;
    }
}

// 树的迭代器
class BinaryTreeIterator<T> implements Iterator<T> {
    private Stack<TreeNode<T>> stack = new Stack<>();

    public BinaryTreeIterator(TreeNode<T> root) {
        pushLeft(root);
    }

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

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

    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        TreeNode<T> node = stack.pop();
        pushLeft(node.right);
        return node.value;
    }
}

// 客户端代码
public class BinaryTreeIteratorExample {
    public static void main(String[] args) {
        TreeNode<Integer> root = new TreeNode<>(1);
        root.left = new TreeNode<>(2);
        root.right = new TreeNode<>(3);
        root.left.left = new TreeNode<>(4);
        root.left.right = new TreeNode<>(5);

        Iterator<Integer> iterator = new BinaryTreeIterator<>(root);

        while (iterator.hasNext()) {
            Integer value = iterator.next();
            System.out.println(value);
        }
    }
}

示例 3: 分页遍历

在分页查询场景中使用迭代器模式。

java 复制代码

// 分页迭代器
class PagingIterator<T> implements Iterator<T> {
    private Iterator<T> currentIterator;
    private int pageSize;
    private int currentPage = 0;
    private Supplier<List<T>> pageSupplier;

    public PagingIterator(int pageSize, Supplier<List<T>> pageSupplier) {
        this.pageSize = pageSize;
        this.pageSupplier = pageSupplier;
        fetchNextPage();
    }

    private void fetchNextPage() {
        List<T> page = pageSupplier.get();
        currentIterator = page.iterator();
        currentPage++;
    }

    @Override
    public boolean hasNext() {
        if (currentIterator.hasNext()) {
            return true;
        }
        fetchNextPage(); // 尝试获取下一页
        return currentIterator.hasNext();
    }

    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return currentIterator.next();
    }
}

// 模拟分页数据提供函数
Supplier<List<Integer>> pageSupplier = new Supplier<List<Integer>>() {
    private int totalPages = 5;
    private int currentPage = 0;

    @Override
    public List<Integer> get() {
        if (currentPage < totalPages) {
            currentPage++;
            return Arrays.asList(1, 2, 3); // 模拟每页的数据
        }
        return Collections.emptyList();
    }
};

// 客户端代码
public class PagingIteratorExample {
    public static void main(String[] args) {
        Iterator<Integer> iterator = new PagingIterator<>(3, pageSupplier);

        while (iterator.hasNext()) {
            Integer number = iterator.next();
            System.out.println(number);
        }
    }
}

总结与建议

以上示例展示了迭代器模式在不同数据结构遍历上的应用。迭代器模式的关键优势是它提供了一种统一的接口来遍历各种类型的数据结构，同时对客户端隐藏了数据结构的实现细节。

在实现迭代器模式时，建议：

保持迭代器接口简单，通常包含 hasNext() 和 next() 方法即可。
确保迭代器正确处理底层数据结构的变更。
考虑迭代器的线程安全性，特别是在多线程环境中使用共享数据结构时。
如果迭代逻辑非常复杂，可以考虑使用访问者模式来进一步分离逻辑和数据结构。

迭代器模式是一种强大的工具，可以使代码更加清晰、灵活，并且易于维护。