Java Iterator 设计模式完全指南

"Iterator 是访问的艺术" —— 从统一访问接口到高性能并行迭代，掌握Iterator就掌握了数据访问的核心

Iterator 是 GoF 设计模式中的行为型模式之一，为集合对象提供统一的访问方式，而不需要暴露其内部结构。想象遥控器：无论电视品牌如何，都可以用相同的按键切换频道，这就是Iterator的精髓。

🎯 快速索引

• 迭代器模式概述 - 理解迭代器的核心价值
• Java Iterator 体系 - Iterator接口家族全景
• Iterator 实现原理 - 深入源码理解机制
• ListIterator 双向迭代 - 支持双向移动的迭代器
• Fail-Fast vs Fail-Safe - 并发安全的两种策略
• Spliterator 并行迭代 - Java 8+ 的高性能并行迭代
• 自定义迭代器 - 为你的数据结构实现迭代器
• 性能优化指南 - 提升迭代效率的技巧

---

🔄 迭代器设计模式概述

核心概念

迭代器模式提供一种顺序访问集合元素的方法，而不需要暴露集合的内部表示：

特性	说明	解决的问题
🎯 统一接口	所有集合使用相同的遍历方式	不同集合的访问方法差异
🔒 封装性	不暴露集合的内部结构	客户端代码与集合内部实现耦合
🔄 灵活性	支持多种遍历策略	固定的遍历方式无法满足需求
🧹 简化性	提供简洁的遍历 API	复杂的集合操作代码
🔧 可扩展性	易于添加新的遍历方式	需要新的遍历功能时修改现有代码

模式结构图

设计原则

public class IteratorPatternPrinciples {

    // 1. 单一职责原则 - 迭代器只负责遍历
    public class SimpleIterator implements Iterator<String> {
        private final List<String> list;
        private int position = 0;

        public SimpleIterator(List<String> list) {
            this.list = list;
        }

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

        @Override
        public String next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return list.get(position++);
        }

        // 只关注遍历逻辑，不关心其他功能
    }

    // 2. 开闭原则 - 可以添加新的迭代器类型而不修改现有代码
    public class ReverseIterator implements Iterator<String> {
        private final List<String> list;
        private int position;

        public ReverseIterator(List<String> list) {
            this.list = list;
            this.position = list.size() - 1;
        }

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

        @Override
        public String next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return list.get(position--);
        }
    }

    // 3. 依赖倒置原则 - 客户端依赖于抽象接口
    public class DataProcessor {
        public void processData(Iterator<String> iterator) {
            while (iterator.hasNext()) {
                String data = iterator.next();
                System.out.println("处理: " + data);
            }
        }
    }

    public void demonstratePrinciples() {
        List<String> data = Arrays.asList("A", "B", "C");
        DataProcessor processor = new DataProcessor();

        // 使用不同的迭代器，处理逻辑不变
        processor.processData(new SimpleIterator(data));
        processor.processData(new ReverseIterator(data));
    }
}

---

🏗️ Java Iterator 体系结构

Iterator 接口层级

核心 Iterator 接口

public interface Iterator<E> {

    /**
     * 检查是否还有下一个元素
     * @return 如果还有元素返回 true，否则返回 false
     */
    boolean hasNext();

    /**
     * 返回下一个元素
     * @return 集合中的下一个元素
     * @throws NoSuchElementException 如果没有更多元素
     */
    E next();

    /**
     * 从底层集合中移除最后一个返回的元素（可选操作）
     * @throws IllegalStateException 如果没有调用 next() 或已经调用过 remove
     * @throws UnsupportedOperationException 如果迭代器不支持删除
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * Java 8+ 对剩余元素执行给定操作
     * @param action 要对每个剩余元素执行的操作
     * @throws NullPointerException 如果 action 为 null
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Iterable 接口

public interface Iterable<T> {

    /**
     * 返回一个类型为 T 的元素的迭代器
     * @return Iterator 实例
     */
    Iterator<T> iterator();

    /**
     * Java 8+ 对 Iterable 的每个元素执行给定操作
     * @param action 要对每个元素执行的操作
     */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    /**
     * Java 8+ 在 Iterable 上创建一个 Spliterator
     * @return Spliterator 实例
     */
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Collection 接口中的迭代器支持

public interface Collection<E> extends Iterable<E> {

    /**
     * 返回此集合中元素的迭代器
     * @return Iterator 实例
     */
    @Override
    Iterator<E> iterator();

    /**
     * Java 8+ 返回此集合的并行 Stream
     * @return 并行 Stream
     */
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }

    /**
     * Java 8+ 返回此集合的顺序 Stream
     * @return 顺序 Stream
     */
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

专用迭代器接口

// 基础数据类型的迭代器
public interface PrimitiveIterator<T, T_CONS> extends Iterator<T> {
    @SuppressWarnings("overloads")
    void forEachRemaining(T_CONS action);

    interface OfInt extends PrimitiveIterator<Integer, IntConsumer> {
        int nextInt();
        @Override
        default Integer next() { return nextInt(); }

        @Override
        default void forEachRemaining(Consumer<? super Integer> action) {
            if (action instanceof IntConsumer) {
                forEachRemaining((IntConsumer) action);
            } else {
                forEachRemaining((IntConsumer) action::accept);
            }
        }
    }

    interface OfLong extends PrimitiveIterator<Long, LongConsumer> {
        long nextLong();
        @Override
        default Long next() { return nextLong(); }
    }

    interface OfDouble extends PrimitiveIterator<Double, DoubleConsumer> {
        double nextDouble();
        @Override
        default Double next() { return nextDouble(); }
    }
}

---

⚙️ Iterator 实现原理

ArrayList 的 Itr 实现

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, Serializable {

    /**
     * ArrayList 的内部迭代器实现
     */
    private class Itr implements Iterator<E> {
        // 下一个要返回的元素的索引
        int cursor;       // index of next element to return

        // 最后一个返回的元素的索引；如果没有则为 -1
        int lastRet = -1;  // index of last element returned; -1 if no such

        // 期望的修改次数，用于快速失败检测
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        /**
         * 检查集合在迭代过程中是否被修改
         * @throws ConcurrentModificationException 如果检测到并发修改
         */
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

LinkedList 的迭代器实现

public class LinkedList<E> extends AbstractSequentialList<E>
        implements List<E>, Deque<E>, Cloneable, Serializable {

    /**
     * LinkedList 的迭代器实现
     */
    private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        ListItr(int index) {
            // assert isPositionIndex(index);
            next = (index == size) ? null : node(index);
            nextIndex = index;
        }

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();

            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        public int nextIndex() {
            return nextIndex;
        }

        public int previousIndex() {
            return nextIndex - 1;
        }

        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount = modCount;
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

Fail-Fast 机制详解

public class FailFastMechanism {

    // 1. modCount 的作用
    public static class ModCountExample {
        private transient int modCount = 0;  // 修改计数器
        private List<String> data = new ArrayList<>();

        public void add(String item) {
            modCount++;  // 每次修改都增加计数
            data.add(item);
        }

        public void remove(int index) {
            modCount++;  // 每次修改都增加计数
            data.remove(index);
        }

        public Iterator<String> iterator() {
            return new Itr();
        }

        private class Itr implements Iterator<String> {
            private int expectedModCount = modCount;  // 记录创建时的修改次数
            private int cursor = 0;

            public boolean hasNext() {
                checkForComodification();
                return cursor < data.size();
            }

            public String next() {
                checkForComodification();
                return data.get(cursor++);
            }

            public void remove() {
                // 删除操作也需要更新 expectedModCount
                if (expectedModCount != modCount) {
                    throw new ConcurrentModificationException();
                }
                ModCountExample.this.remove(--cursor);
                expectedModCount = modCount;  // 同步修改次数
            }

            private void checkForComodification() {
                if (expectedModCount != modCount) {
                    throw new ConcurrentModificationException();
                }
            }
        }
    }

    // 2. Fail-Fast 演示
    public static void demonstrateFailFast() {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

        // 在迭代时修改集合
        try {
            for (String item : list) {
                if ("B".equals(item)) {
                    list.remove(item);  // 在迭代过程中修改集合
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("Fail-Fast 触发: " + e.getMessage());
        }

        // 正确的删除方式
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if ("B".equals(item)) {
                iterator.remove();  // 使用迭代器的 remove 方法
            }
        }
        System.out.println("安全删除后: " + list);
    }

    // 3. modCount 的线程安全问题
    public static void demonstrateThreadSafetyIssue() throws InterruptedException {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));

        // 线程1：迭代器
        Thread iteratorThread = new Thread(() -> {
            try {
                Iterator<String> it = list.iterator();
                while (it.hasNext()) {
                    String item = it.next();
                    System.out.println("读取: " + item);
                    Thread.sleep(100);  // 模拟处理时间
                }
            } catch (ConcurrentModificationException e) {
                System.out.println("迭代器检测到并发修改: " + e.getMessage());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 线程2：修改集合
        Thread modifierThread = new Thread(() -> {
            try {
                Thread.sleep(150);
                list.remove("C");  // 在迭代过程中修改集合
                System.out.println("修改集合: 移除 C");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        iteratorThread.start();
        modifierThread.start();

        iteratorThread.join();
        modifierThread.join();
    }
}

Iterator 的内存效率优化

public class IteratorMemoryOptimization {

    // 1. 延迟加载迭代器
    public static class LazyLoadingIterator<T> implements Iterator<T> {
        private final Supplier<T> supplier;
        private T nextElement;
        private boolean hasNext = true;

        public LazyLoadingIterator(Supplier<T> supplier) {
            this.supplier = supplier;
        }

        @Override
        public boolean hasNext() {
            return hasNext;
        }

        @Override
        public T next() {
            if (!hasNext) {
                throw new NoSuchElementException();
            }
            T current = nextElement;
            try {
                nextElement = supplier.get();
            } catch (Exception e) {
                hasNext = false;
                nextElement = null;
            }
            return current;
        }
    }

    // 2. 分页迭代器
    public static class PagedIterator<T> implements Iterator<T> {
        private final Function<Integer, List<T>> pageLoader;
        private final int pageSize;

        private Iterator<T> currentPage;
        private int currentPageIndex = 0;
        private boolean hasMorePages = true;

        public PagedIterator(Function<Integer, List<T>> pageLoader, int pageSize) {
            this.pageLoader = pageLoader;
            this.pageSize = pageSize;
            loadNextPage();
        }

        private void loadNextPage() {
            if (!hasMorePages) return;

            List<T> page = pageLoader.apply(currentPageIndex++);
            if (page == null || page.isEmpty()) {
                hasMorePages = false;
                currentPage = Collections.emptyIterator();
            } else {
                currentPage = page.iterator();
                hasMorePages = page.size() == pageSize;
            }
        }

        @Override
        public boolean hasNext() {
            while (!currentPage.hasNext() && hasMorePages) {
                loadNextPage();
            }
            return currentPage.hasNext();
        }

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

    // 3. 缓存迭代器（避免重复计算）
    public static class CachingIterator<T> implements Iterator<T> {
        private final Iterator<T> source;
        private final Queue<T> cache = new ArrayDeque<>();
        private boolean sourceExhausted = false;

        public CachingIterator(Iterator<T> source) {
            this.source = source;
        }

        @Override
        public boolean hasNext() {
            if (!cache.isEmpty()) {
                return true;
            }
            return source.hasNext();
        }

        @Override
        public T next() {
            if (!cache.isEmpty()) {
                return cache.poll();
            }
            return source.next();
        }

        // 重置迭代器到开始位置
        public void reset() {
            // 将之前遍历过的元素重新放入缓存
            // 这需要在迭代时缓存所有元素
            sourceExhausted = false;
        }

        public Iterator<T> cachedIterator() {
            return new ArrayList<>(cache).iterator();
        }
    }

    // 使用示例
    public static void demonstrateOptimizations() {
        // 1. 延迟加载示例
        System.out.println("=== 延迟加载迭代器 ===");
        LazyLoadingIterator<Integer> lazyIterator =
            new LazyLoadingIterator<>(() -> {
                int value = (int) (Math.random() * 100);
                System.out.println("生成值: " + value);
                return value;
            });

        for (int i = 0; i < 5; i++) {
            if (lazyIterator.hasNext()) {
                System.out.println("获取: " + lazyIterator.next());
            }
        }

        // 2. 分页迭代器示例
        System.out.println("\n=== 分页迭代器 ===");
        PagedIterator<String> pagedIterator = new PagedIterator<>(
            pageNumber -> {
                System.out.println("加载第 " + pageNumber + " 页");
                // 模拟数据库分页查询
                if (pageNumber >= 3) return Collections.emptyList();
                return Arrays.asList(
                    "Page" + pageNumber + "-Item1",
                    "Page" + pageNumber + "-Item2",
                    "Page" + pageNumber + "-Item3"
                );
            },
            3  // 每页3条记录
        );

        int count = 0;
        while (pagedIterator.hasNext() && count < 10) {
            System.out.println("处理: " + pagedIterator.next());
            count++;
        }
    }
}

---

🔄 ListIterator 双向迭代器

ListIterator 接口定义

public interface ListIterator<E> extends Iterator<E> {

    /**
     * 检查是否有前一个元素
     * @return 如果有前一个元素返回 true
     */
    boolean hasPrevious();

    /**
     * 检查是否有下一个元素
     * @return 如果有下一个元素返回 true
     */
    @Override
    boolean hasNext();

    /**
     * 返回下一个元素
     * @return 列表中的下一个元素
     * @throws NoSuchElementException 如果没有下一个元素
     */
    @Override
    E next();

    /**
     * 返回前一个元素
     * @return 列表中的前一个元素
     * @throws NoSuchElementException 如果没有前一个元素
     */
    E previous();

    /**
     * 返回下一个元素的索引
     * @return 下一个元素的索引，如果迭代器在列表末尾则返回列表大小
     */
    int nextIndex();

    /**
     * 返回前一个元素的索引
     * @return 前一个元素的索引，如果迭代器在列表开头则返回 -1
     */
    int previousIndex();

    /**
     * 从列表中移除上次由 next() 或 previous() 返回的元素
     * @throws IllegalStateException 如果没有调用过 next() 或 previous()
     */
    @Override
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * 用指定元素替换 next() 或 previous() 返回的最后一个元素
     * @param e 用于替换的元素
     * @throws IllegalStateException 如果没有调用过 next() 或 previous()
     */
    default void set(E e) {
        throw new UnsupportedOperationException("set");
    }

    /**
     * 将指定的元素插入列表
     * @param e 要插入的元素
     */
    default void add(E e) {
        throw new UnsupportedOperationException("add");
    }
}

ListIterator 使用示例

public class ListIteratorExamples {

    public static void demonstrateListIterator() {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));

        // 从索引2开始创建 ListIterator
        ListIterator<String> iterator = list.listIterator(2);

        System.out.println("=== 正向遍历 ===");
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.printf("元素: %s, 索引: %d, 下一个索引: %d%n",
                    element, iterator.previousIndex(), iterator.nextIndex());
        }

        System.out.println("\n=== 反向遍历 ===");
        while (iterator.hasPrevious()) {
            String element = iterator.previous();
            System.out.printf("元素: %s, 索引: %d, 前一个索引: %d%n",
                    element, iterator.nextIndex(), iterator.previousIndex());
        }

        System.out.println("\n=== 修改操作 ===");
        iterator = list.listIterator();

        while (iterator.hasNext()) {
            String element = iterator.next();
            if ("C".equals(element)) {
                // 替换元素
                iterator.set("C-Modified");
                System.out.println("替换 C 为 C-Modified");
            } else if ("A".equals(element)) {
                // 在A后插入新元素
                iterator.add("A-After");
                System.out.println("在 A 后插入 A-After");
            } else if ("E".equals(element)) {
                // 删除元素
                iterator.remove();
                System.out.println("删除 E");
            }
        }

        System.out.println("最终列表: " + list);
    }

    // 双向搜索示例
    public static void bidirectionalSearch(List<Integer> numbers, int target) {
        ListIterator<Integer> forwardIterator = numbers.listIterator();
        ListIterator<Integer> backwardIterator = numbers.listIterator(numbers.size());

        int forwardIndex = -1;
        int backwardIndex = -1;

        // 从两端同时搜索
        while (forwardIterator.hasNext() && backwardIterator.hasPrevious()) {

            // 正向搜索
            if (forwardIndex == -1) {
                int forwardValue = forwardIterator.next();
                if (forwardValue == target) {
                    forwardIndex = forwardIterator.previousIndex();
                }
            }

            // 反向搜索
            if (backwardIndex == -1) {
                int backwardValue = backwardIterator.previous();
                if (backwardValue == target) {
                    backwardIndex = backwardIterator.nextIndex();
                }
            }

            // 检查是否找到了目标
            if (forwardIndex != -1 && backwardIndex != -1) {
                System.out.printf("从两端找到目标 %d: 正向索引=%d, 反向索引=%d%n",
                        target, forwardIndex, backwardIndex);
                return;
            }

            // 检查是否已经交错
            if (forwardIterator.nextIndex() >= backwardIterator.nextIndex()) {
                break;
            }
        }

        System.out.println("未找到目标: " + target);
    }

    // 文本编辑器模拟（光标移动）
    public static class TextEditor {
        private final List<Character> characters = new ArrayList<>();
        private int cursorPosition = 0;

        public void insertText(String text) {
            for (char c : text.toCharArray()) {
                characters.add(cursorPosition, c);
                cursorPosition++;
            }
        }

        public void deleteBeforeCursor(int count) {
            ListIterator<Character> iterator = characters.listIterator(cursorPosition);
            for (int i = 0; i < count && iterator.hasPrevious(); i++) {
                iterator.previous();
                iterator.remove();
                cursorPosition--;
            }
        }

        public void deleteAfterCursor(int count) {
            ListIterator<Character> iterator = characters.listIterator(cursorPosition);
            for (int i = 0; i < count && iterator.hasNext(); i++) {
                iterator.next();
                iterator.remove();
            }
        }

        public String getTextBeforeCursor() {
            StringBuilder sb = new StringBuilder();
            ListIterator<Character> iterator = characters.listIterator(cursorPosition);
            while (iterator.hasPrevious()) {
                sb.insert(0, iterator.previous());
            }
            return sb.toString();
        }

        public String getTextAfterCursor() {
            StringBuilder sb = new StringBuilder();
            ListIterator<Character> iterator = characters.listIterator(cursorPosition);
            while (iterator.hasNext()) {
                sb.append(iterator.next());
            }
            return sb.toString();
        }

        public void moveCursorLeft(int positions) {
            cursorPosition = Math.max(0, cursorPosition - positions);
        }

        public void moveCursorRight(int positions) {
            cursorPosition = Math.min(characters.size(), cursorPosition + positions);
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            int i = 0;
            for (char c : characters) {
                if (i == cursorPosition) {
                    sb.append('|');  // 光标位置
                }
                sb.append(c);
                i++;
            }
            if (i == cursorPosition) {
                sb.append('|');  // 光标在末尾
            }
            return sb.toString();
        }
    }

    public static void demonstrateTextEditor() {
        TextEditor editor = new TextEditor();

        editor.insertText("Hello World");
        System.out.println("初始文本: " + editor);

        editor.moveCursorLeft(6);  // 移动到 Hello 和 World 之间
        editor.insertText(" Beautiful");
        System.out.println("插入后: " + editor);

        editor.moveCursorLeft(10);
        editor.deleteBeforeCursor(5);  // 删除 "Hello"
        System.out.println("删除前5个字符: " + editor);

        editor.moveCursorRight(3);
        editor.deleteAfterCursor(6);   // 删除 " Beautiful"
        System.out.println("删除后6个字符: " + editor);

        System.out.println("光标前文本: '" + editor.getTextBeforeCursor() + "'");
        System.out.println("光标后文本: '" + editor.getTextAfterCursor() + "'");
    }

    // 撤销/重做功能实现
    public static class UndoRedoManager {
        private final List<String> history = new ArrayList<>();
        private int currentIndex = -1;  // 当前状态的索引

        public void saveState(String state) {
            // 移除当前位置之后的所有历史记录
            while (history.size() > currentIndex + 1) {
                history.remove(history.size() - 1);
            }

            history.add(state);
            currentIndex++;
        }

        public String undo() {
            if (canUndo()) {
                currentIndex--;
                return history.get(currentIndex);
            }
            return null;
        }

        public String redo() {
            if (canRedo()) {
                currentIndex++;
                return history.get(currentIndex);
            }
            return null;
        }

        public boolean canUndo() {
            return currentIndex > 0;
        }

        public boolean canRedo() {
            return currentIndex < history.size() - 1;
        }

        public ListIterator<String> getHistoryIterator() {
            return history.listIterator();
        }

        public void showHistory() {
            System.out.println("=== 历史记录 ===");
            ListIterator<String> iterator = getHistoryIterator();
            int index = 0;
            while (iterator.hasNext()) {
                String state = iterator.next();
                String marker = (index == currentIndex) ? " <-- 当前" : "";
                System.out.printf("[%d] %s%s%n", index, state, marker);
                index++;
            }
        }
    }

    public static void demonstrateUndoRedo() {
        UndoRedoManager manager = new UndoRedoManager();

        manager.saveState("初始状态");
        manager.saveState("添加元素 A");
        manager.saveState("添加元素 B");
        manager.saveState("删除元素 A");
        manager.saveState("修改元素 B");

        manager.showHistory();

        System.out.println("\n=== 撤销操作 ===");
        System.out.println("撤销到: " + manager.undo());
        System.out.println("撤销到: " + manager.undo());

        manager.showHistory();

        System.out.println("\n=== 重做操作 ===");
        System.out.println("重做到: " + manager.redo());

        manager.showHistory();
    }

    public static void main(String[] args) {
        demonstrateListIterator();

        System.out.println("\n=== 双向搜索 ===");
        List<Integer> numbers = Arrays.asList(1, 3, 5, 7, 9, 11, 13, 15, 17, 19);
        bidirectionalSearch(numbers, 11);
        bidirectionalSearch(numbers, 8);

        System.out.println("\n=== 文本编辑器模拟 ===");
        demonstrateTextEditor();

        System.out.println("\n=== 撤销/重做功能 ===");
        demonstrateUndoRedo();
    }
}

---

⚡ Fail-Fast vs Fail-Safe 机制

两种机制对比

public class FailFastVsFailSafe {

    // 1. Fail-Fast 迭代器 (快速失败)
    public static class FailFastExample {
        public static void demonstrateFailFast() {
            List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));

            System.out.println("=== Fail-Fast 演示 ===");

            try {
                // 使用增强 for 循环（内部使用 Iterator）
                for (String item : list) {
                    System.out.println("处理: " + item);
                    if ("B".equals(item)) {
                        list.remove(item);  // 在迭代时修改集合
                    }
                }
            } catch (ConcurrentModificationException e) {
                System.out.println("Fail-Fast 异常: " + e.getClass().getSimpleName());
                System.out.println("原因: 在迭代过程中检测到集合被修改");
            }

            System.out.println("原始列表: " + list);
        }
    }

    // 2. Fail-Safe 迭代器 (安全失败)
    public static class FailSafeExample {
        public static void demonstrateFailSafe() {
            List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D"));

            System.out.println("=== Fail-Safe 演示 ===");

            // 使用 CopyOnWriteArrayList 的迭代器
            List<String> copyOnWriteList = new CopyOnWriteArrayList<>(list);

            for (String item : copyOnWriteList) {
                System.out.println("处理: " + item);
                if ("B".equals(item)) {
                    copyOnWriteList.remove(item);  // 不会抛出异常
                }
            }

            System.out.println("修改后的列表: " + copyOnWriteList);

            // 使用 Collections.synchronizedList + 手动同步
            List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>(list));

            synchronized (synchronizedList) {
                Iterator<String> iterator = synchronizedList.iterator();
                while (iterator.hasNext()) {
                    String item = iterator.next();
                    System.out.println("处理: " + item);
                    if ("B".equals(item)) {
                        iterator.remove();  // 安全的删除方式
                    }
                }
            }

            System.out.println("同步列表: " + synchronizedList);
        }
    }

    // 3. 自定义 Fail-Safe 迭代器
    public static class FailSafeIterator<T> implements Iterator<T> {
        private final List<T> snapshot;
        private final Iterator<T> iterator;

        public FailSafeIterator(Collection<T> collection) {
            // 创建快照
            this.snapshot = new ArrayList<>(collection);
            this.iterator = snapshot.iterator();
        }

        @Override
        public boolean hasNext() {
            return iterator.hasNext();
        }

        @Override
        public T next() {
            return iterator.next();
        }

        @Override
        public void remove() {
            iterator.remove();
            // 注意：这里只会从快照中移除，不会影响原始集合
        }
    }

    // 4. 内存占用对比
    public static class MemoryUsageComparison {
        public static void compareMemoryUsage() {
            int dataSize = 1_000_000;

            // Fail-Fast: 不需要额外内存
            List<String> failFastList = new ArrayList<>();
            for (int i = 0; i < dataSize; i++) {
                failFastList.add("item" + i);
            }

            // Fail-Safe: 需要创建快照，内存翻倍
            List<String> failSafeList = new CopyOnWriteArrayList<>();
            for (int i = 0; i < dataSize; i++) {
                failSafeList.add("item" + i);
            }

            // 获取内存使用情况
            Runtime runtime = Runtime.getRuntime();

            System.out.println("=== 内存使用对比 ===");
            System.gc();
            long memoryBefore = runtime.totalMemory() - runtime.freeMemory();

            // Fail-Fast 迭代器
            Iterator<String> failFastIterator = failFastList.iterator();
            int failFastCount = 0;
            while (failFastIterator.hasNext() && failFastCount < 1000) {
                failFastIterator.next();
                failFastCount++;
            }

            long memoryAfterFailFast = runtime.totalMemory() - runtime.freeMemory();
            long failFastMemoryUsage = memoryAfterFailFast - memoryBefore;

            System.gc();
            memoryBefore = runtime.totalMemory() - runtime.freeMemory();

            // Fail-Safe 迭代器
            Iterator<String> failSafeIterator = failSafeList.iterator();
            int failSafeCount = 0;
            while (failSafeIterator.hasNext() && failSafeCount < 1000) {
                failSafeIterator.next();
                failSafeCount++;
            }

            long memoryAfterFailSafe = runtime.totalMemory() - runtime.freeMemory();
            long failSafeMemoryUsage = memoryAfterFailSafe - memoryBefore;

            System.out.printf("Fail-Fast 迭代器内存使用: %d bytes%n", failFastMemoryUsage);
            System.out.printf("Fail-Safe 迭代器内存使用: %d bytes%n", failSafeMemoryUsage);
            System.out.printf("内存差异: %.1fx%n", (double) failSafeMemoryUsage / failFastMemoryUsage);
        }
    }

    // 5. 性能对比测试
    public static class PerformanceComparison {
        public static void comparePerformance() {
            int dataSize = 100_000;

            // Fail-Fast 测试
            List<String> failFastList = new ArrayList<>();
            for (int i = 0; i < dataSize; i++) {
                failFastList.add("item" + i);
            }

            long startTime = System.nanoTime();
            Iterator<String> failFastIterator = failFastList.iterator();
            while (failFastIterator.hasNext()) {
                failFastIterator.next();
            }
            long failFastTime = System.nanoTime() - startTime;

            // Fail-Safe 测试
            List<String> failSafeList = new CopyOnWriteArrayList<>();
            for (int i = 0; i < dataSize; i++) {
                failSafeList.add("item" + i);
            }

            startTime = System.nanoTime();
            Iterator<String> failSafeIterator = failSafeList.iterator();
            while (failSafeIterator.hasNext()) {
                failSafeIterator.next();
            }
            long failSafeTime = System.nanoTime() - startTime;

            System.out.println("=== 性能对比 ===");
            System.out.printf("Fail-Fast 迭代时间: %.2f ms%n", failFastTime / 1_000_000.0);
            System.out.printf("Fail-Safe 迭代时间: %.2f ms%n", failSafeTime / 1_000_000.0);
            System.out.printf("性能差异: %.1fx%n", (double) failSafeTime / failFastTime);
        }
    }

    // 6. 使用场景建议
    public static class UsageGuidelines {

        /**
         * 选择 Fail-Fast 迭代器的场景
         */
        public static void failFastScenarios() {
            System.out.println("=== Fail-Fast 适用场景 ===");
            System.out.println("1. 单线程环境下的集合遍历");
            System.out.println("2. 需要快速检测并发修改的场景");
            System.out.println("3. 内存敏感的应用");
            System.out.println("4. 对性能要求较高的场景");

            // 示例：数据验证
            List<String> data = Arrays.asList("name", "age", "email", "phone");
            for (String field : data) {
                if (field == null || field.trim().isEmpty()) {
                    throw new IllegalArgumentException("字段不能为空: " + field);
                }
                System.out.println("验证通过: " + field);
            }
        }

        /**
         * 选择 Fail-Safe 迭代器的场景
         */
        public static void failSafeScenarios() {
            System.out.println("\n=== Fail-Safe 适用场景 ===");
            System.out.println("1. 多线程环境下的集合遍历");
            System.out.println("2. 遍历过程中集合可能被修改的场景");
            System.out.println("3. 需要保证数据一致性的场景");
            System.out.println("4. 缓存或快照遍历的场景");

            // 示例：监听器通知
            CopyOnWriteArraySet<EventListener> listeners = new CopyOnWriteArraySet<>();
            listeners.add(event -> System.out.println("监听器1处理: " + event));
            listeners.add(event -> System.out.println("监听器2处理: " + event));
            listeners.add(event -> System.out.println("监听器3处理: " + event));

            // 通知过程中可以安全地添加/删除监听器
            for (EventListener listener : listeners) {
                listener.handleEvent("事件数据");

                // 模拟在通知过程中添加新监听器
                if (listeners.size() == 3) {
                    listeners.add(event -> System.out.println("新监听器处理: " + event));
                }
            }

            // 再次通知，新监听器会被调用
            System.out.println("\n第二次通知:");
            for (EventListener listener : listeners) {
                listener.handleEvent("事件数据2");
            }
        }

        @FunctionalInterface
        interface EventListener {
            void handleEvent(String event);
        }
    }

    public static void main(String[] args) {
        demonstrateFailFast();
        demonstrateFailSafe();
        compareMemoryUsage();
        comparePerformance();
        UsageGuidelines.failFastScenarios();
        UsageGuidelines.failSafeScenarios();
    }
}

---

🚀 Spliterator 并行迭代器

Spliterator 接口定义

public interface Spliterator<T> {

    // 特征常量
    int ORDERED = 0x00000010;    // 遇到顺序是定义好的
    int DISTINCT = 0x00000001;    // 遇到的元素没有重复的
    int SORTED = 0x00000004;      // 遇到的元素是有序的
    int SIZED = 0x00000040;       // 在遍历或分割前estimateSize()返回精确值
    int NONNULL = 0x00000100;     // 遇到的元素不会为null
    int IMMUTABLE = 0x00000400;    // 元素源不能被修改
    int CONCURRENT = 0x00001000;   // 元素源可以被多个线程安全地并发修改
    int SUBSIZED = 0x00004000;    // 所有的分割器都是SIZED和SUBSIZED的

    /**
     * 尝试分割 Spliterator
     * @return 如果分割成功返回新的 Spliterator，否则返回 null
     */
    Spliterator<T> trySplit();

    /**
     * 对剩余元素执行动作
     * @param action 要执行的动作
     * @return 如果还有元素返回 true
     */
    boolean tryAdvance(Consumer<? super T> action);

    /**
     * 遍历所有剩余元素
     * @param action 要执行的动作
     */
    default void forEachRemaining(Consumer<? super T> action) {
        do { } while (tryAdvance(action));
    }

    /**
     * 估算剩余元素数量
     * @return 估算的剩余元素数量
     */
    default long estimateSize() {
        return Long.MAX_VALUE;
    }

    /**
     * 返回特征值
     * @return 特征值的按位或组合
     */
    default int characteristics() {
        return 0;
    }

    /**
     * 如果 Spliterator 具有给定特征，则返回 true
     */
    default boolean hasCharacteristics(int characteristics) {
        return (characteristics() & characteristics) == characteristics;
    }

    /**
     * 获取比较器（如果元素是有序的）
     */
    default Comparator<? super T> getComparator() {
        if (hasCharacteristics(SORTED))
            return null;
        throw new IllegalStateException();
    }

    // Java 9+ 新增方法
    default long getExactSizeIfKnown() {
        return hasCharacteristics(SIZED) ? estimateSize() : -1;
    }
}

Spliterator 使用示例

public class SpliteratorExamples {

    // 1. 基础 Spliterator 使用
    public static void basicSpliteratorUsage() {
        List<String> words = Arrays.asList("Java", "Python", "JavaScript", "Go", "Rust", "C++", "TypeScript");

        System.out.println("=== 基础 Spliterator 遍历 ===");
        Spliterator<String> spliterator = words.spliterator();

        System.out.println("特征值: " + Integer.toHexString(spliterator.characteristics()));
        System.out.println("估算大小: " + spliterator.estimateSize());

        // 使用 tryAdvance
        System.out.println("\n使用 tryAdvance:");
        while (spliterator.tryAdvance(word -> System.out.println("处理: " + word))) {
            // 继续处理
        }

        // 重新创建 Spliterator
        spliterator = words.spliterator();

        // 使用 forEachRemaining
        System.out.println("\n使用 forEachRemaining:");
        spliterator.forEachRemaining(word -> System.out.println("剩余: " + word));
    }

    // 2. 并行处理示例
    public static void parallelProcessing() {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            numbers.add(i);
        }

        System.out.println("=== 并行处理示例 ===");

        // 获取 Spliterator
        Spliterator<Integer> spliterator = numbers.spliterator();
        System.out.println("原始大小: " + spliterator.estimateSize());

        // 分割任务
        AtomicInteger sum = new AtomicInteger(0);
        AtomicInteger processedCount = new AtomicInteger(0);

        processParallel(spliterator, sum, processedCount, 0);

        System.out.println("并行处理完成");
        System.out.println("总和: " + sum.get());
        System.out.println("处理数量: " + processedCount.get());
    }

    private static void processParallel(Spliterator<Integer> spliterator,
                                      AtomicInteger sum,
                                      AtomicInteger processedCount,
                                      int depth) {
        // 基础情况：元素数量少或达到最大深度
        if (spliterator.estimateSize() <= 10 || depth >= 3) {
            System.out.println("处理任务 (深度: " + depth + ", 大小: " + spliterator.estimateSize() + ")");
            spliterator.forEachRemaining(num -> {
                sum.addAndGet(num);
                processedCount.incrementAndGet();
            });
            return;
        }

        // 尝试分割
        Spliterator<Integer> rightSplit = spliterator.trySplit();
        if (rightSplit == null) {
            // 无法分割，直接处理
            processParallel(spliterator, sum, processedCount, depth);
        } else {
            // 并行处理两个分割
            System.out.println("分割任务 - 左侧: " + spliterator.estimateSize() +
                             ", 右侧: " + rightSplit.estimateSize());

            // 在实际应用中，这里应该使用线程池
            Thread leftThread = new Thread(() ->
                processParallel(spliterator, sum, processedCount, depth + 1));
            Thread rightThread = new Thread(() ->
                processParallel(rightSplit, sum, processedCount, depth + 1));

            leftThread.start();
            rightThread.start();

            try {
                leftThread.join();
                rightThread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    // 3. 自定义 Spliterator
    public static class RangeSpliterator implements Spliterator.OfInt {
        private final int from;
        private final int to;
        private int current;
        private final int threshold;  // 分割阈值

        public RangeSpliterator(int from, int to, int threshold) {
            this.from = from;
            this.to = to;
            this.current = from;
            this.threshold = threshold;
        }

        @Override
        public boolean tryAdvance(IntConsumer action) {
            if (action == null) {
                throw new NullPointerException();
            }

            if (current >= to) {
                return false;
            }

            action.accept(current++);
            return true;
        }

        @Override
        public Spliterator.OfInt trySplit() {
            int remaining = to - current;
            if (remaining <= threshold) {
                return null;  // 太小了，不再分割
            }

            int mid = current + remaining / 2;
            RangeSpliterator rightSplit = new RangeSpliterator(mid, to, threshold);
            this.to = mid;
            return rightSplit;
        }

        @Override
        public long estimateSize() {
            return to - current;
        }

        @Override
        public int characteristics() {
            return ORDERED | SIZED | SUBSIZED | IMMUTABLE | NONNULL;
        }
    }

    public static void customSpliteratorDemo() {
        System.out.println("\n=== 自定义 Spliterator 演示 ===");

        RangeSpliterator rangeSpliterator = new RangeSpliterator(1, 101, 20);

        System.out.println("总估算大小: " + rangeSpliterator.estimateSize());
        System.out.println("特征: " + Integer.toHexString(rangeSpliterator.characteristics()));

        AtomicInteger sum = new AtomicInteger(0);
        AtomicInteger count = new AtomicInteger(0);

        // 递归分割并处理
        processRangeSpliterator(rangeSpliterator, sum, count);

        System.out.println("总和: " + sum.get());
        System.out.println("计数: " + count.get());
    }

    private static void processRangeSpliterator(RangeSpliterator spliterator,
                                              AtomicInteger sum, AtomicInteger count) {
        Spliterator.OfInt rightSplit = spliterator.trySplit();

        if (rightSplit == null) {
            // 直接处理
            spliterator.forEachRemaining(num -> {
                sum.addAndGet(num);
                count.incrementAndGet();
            });
        } else {
            // 并行处理
            processRangeSpliterator((RangeSpliterator) spliterator, sum, count);
            processRangeSpliterator((RangeSpliterator) rightSplit, sum, count);
        }
    }

    // 4. 文件处理 Spliterator
    public static class FileLineSpliterator implements Spliterator<String> {
        private final BufferedReader reader;
        private String nextLine;
        private final long estimatedSize;

        public FileLineSpliterator(BufferedReader reader, long estimatedSize) {
            this.reader = reader;
            this.estimatedSize = estimatedSize;
            this.nextLine = readNextLine();
        }

        private String readNextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        @Override
        public boolean tryAdvance(Consumer<? super String> action) {
            if (action == null) {
                throw new NullPointerException();
            }

            if (nextLine == null) {
                return false;
            }

            action.accept(nextLine);
            nextLine = readNextLine();
            return true;
        }

        @Override
        public Spliterator<String> trySplit() {
            // 文件的 Spliterator 很难有效分割
            // 这里返回 null 表示不支持分割
            return null;
        }

        @Override
        public long estimateSize() {
            return nextLine == null ? 0 : estimatedSize;
        }

        @Override
        public int characteristics() {
            return ORDERED | NONNULL;
        }
    }

    // 5. 性能基准测试
    public static class SpliteratorPerformanceBenchmark {
        public static void benchmarkSequentialVsParallel() {
            List<Integer> numbers = new ArrayList<>();
            for (int i = 0; i < 1_000_000; i++) {
                numbers.add(i);
            }

            // 顺序 Stream (内部使用 Spliterator)
            long startTime = System.nanoTime();
            long sequentialSum = numbers.stream()
                    .mapToLong(Integer::longValue)
                    .sum();
            long sequentialTime = System.nanoTime() - startTime;

            // 并行 Stream (内部使用 Spliterator 分割)
            startTime = System.nanoTime();
            long parallelSum = numbers.parallelStream()
                    .mapToLong(Integer::longValue)
                    .sum();
            long parallelTime = System.nanoTime() - startTime;

            System.out.println("\n=== 性能基准测试 ===");
            System.out.printf("顺序处理时间: %.2f ms%n", sequentialTime / 1_000_000.0);
            System.out.printf("并行处理时间: %.2f ms%n", parallelTime / 1_000_000.0);
            System.out.printf("性能提升: %.1fx%n", (double) sequentialTime / parallelTime);
            System.out.printf("结果一致性: %s%n", sequentialSum == parallelSum ? "一致" : "不一致");
        }
    }

    public static void main(String[] args) {
        basicSpliteratorUsage();
        parallelProcessing();
        customSpliteratorDemo();
        SpliteratorPerformanceBenchmark.benchmarkSequentialVsParallel();
    }
}

---

🔧 自定义迭代器实现

为自定义数据结构实现迭代器

public class CustomIteratorExamples {

    // 1. 二叉树的迭代器
    public static class TreeNode<T> {
        T value;
        TreeNode<T> left;
        TreeNode<T> right;

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

        public TreeNode(T value, TreeNode<T> left, TreeNode<T> right) {
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    // 中序遍历迭代器
    public static class InOrderIterator<T> implements Iterator<T> {
        private final Stack<TreeNode<T>> stack = new Stack<>();
        private TreeNode<T> current;

        public InOrderIterator(TreeNode<T> root) {
            this.current = root;
            pushLeftNodes(root);
        }

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

        @Override
        public boolean hasNext() {
            return !stack.isEmpty() || current != null;
        }

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

            TreeNode<T> node = stack.pop();
            if (node.right != null) {
                pushLeftNodes(node.right);
            }

            return node.value;
        }
    }

    // 前序遍历迭代器
    public static class PreOrderIterator<T> implements Iterator<T> {
        private final Stack<TreeNode<T>> stack = new Stack<>();

        public PreOrderIterator(TreeNode<T> root) {
            if (root != null) {
                stack.push(root);
            }
        }

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

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

            TreeNode<T> node = stack.pop();
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }

            return node.value;
        }
    }

    // 层序遍历迭代器
    public static class LevelOrderIterator<T> implements Iterator<T> {
        private final Queue<TreeNode<T>> queue = new LinkedList<>();

        public LevelOrderIterator(TreeNode<T> root) {
            if (root != null) {
                queue.offer(root);
            }
        }

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

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

            TreeNode<T> node = queue.poll();
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }

            return node.value;
        }
    }

    // 2. 图的迭代器 (深度优先搜索)
    public static class GraphNode<T> {
        T value;
        List<GraphNode<T>> neighbors;

        public GraphNode(T value) {
            this.value = value;
            this.neighbors = new ArrayList<>();
        }

        public void addNeighbor(GraphNode<T> neighbor) {
            neighbors.add(neighbor);
        }
    }

    public static class GraphDFSIterator<T> implements Iterator<T> {
        private final Set<GraphNode<T>> visited = new HashSet<>();
        private final Stack<GraphNode<T>> stack = new Stack<>();

        public GraphDFSIterator(GraphNode<T> start) {
            if (start != null) {
                stack.push(start);
            }
        }

        @Override
        public boolean hasNext() {
            while (!stack.isEmpty()) {
                GraphNode<T> node = stack.peek();
                if (!visited.contains(node)) {
                    return true;
                }
                stack.pop();
            }
            return false;
        }

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

            GraphNode<T> node = stack.pop();
            if (visited.contains(node)) {
                return next();  // 跳过已访问的节点
            }

            visited.add(node);
            // 将邻居按相反顺序压栈，确保按正序访问
            for (int i = node.neighbors.size() - 1; i >= 0; i--) {
                if (!visited.contains(node.neighbors.get(i))) {
                    stack.push(node.neighbors.get(i));
                }
            }

            return node.value;
        }
    }

    // 3. 分页数据的迭代器
    public static class PaginationDataSource<T> {
        private final List<T> allData;
        private final int pageSize;

        public PaginationDataSource(List<T> allData, int pageSize) {
            this.allData = new ArrayList<>(allData);
            this.pageSize = pageSize;
        }

        public List<T> getPage(int pageNumber) {
            int startIndex = pageNumber * pageSize;
            int endIndex = Math.min(startIndex + pageSize, allData.size());

            if (startIndex >= allData.size()) {
                return Collections.emptyList();
            }

            return allData.subList(startIndex, endIndex);
        }

        public int getTotalPages() {
            return (int) Math.ceil((double) allData.size() / pageSize);
        }
    }

    public static class PaginationIterator<T> implements Iterator<T> {
        private final PaginationDataSource<T> dataSource;
        private Iterator<T> currentPageIterator;
        private int currentPage = 0;

        public PaginationIterator(PaginationDataSource<T> dataSource) {
            this.dataSource = dataSource;
            loadNextPage();
        }

        private void loadNextPage() {
            List<T> page = dataSource.getPage(currentPage);
            currentPageIterator = page.iterator();
            currentPage++;
        }

        @Override
        public boolean hasNext() {
            while (!currentPageIterator.hasNext() && currentPage < dataSource.getTotalPages()) {
                loadNextPage();
            }
            return currentPageIterator.hasNext();
        }

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

    // 4. 条件过滤迭代器
    public static class FilterIterator<T> implements Iterator<T> {
        private final Iterator<T> source;
        private final Predicate<T> predicate;
        private T nextElement;
        private boolean hasNextElement = false;

        public FilterIterator(Iterator<T> source, Predicate<T> predicate) {
            this.source = source;
            this.predicate = predicate;
            advanceToNextMatch();
        }

        private void advanceToNextMatch() {
            hasNextElement = false;
            nextElement = null;

            while (source.hasNext()) {
                T element = source.next();
                if (predicate.test(element)) {
                    nextElement = element;
                    hasNextElement = true;
                    break;
                }
            }
        }

        @Override
        public boolean hasNext() {
            return hasNextElement;
        }

        @Override
        public T next() {
            if (!hasNextElement) {
                throw new NoSuchElementException();
            }

            T result = nextElement;
            advanceToNextMatch();
            return result;
        }
    }

    // 5. 转换迭代器
    public static class TransformIterator<F, T> implements Iterator<T> {
        private final Iterator<F> source;
        private final Function<F, T> transformer;

        public TransformIterator(Iterator<F> source, Function<F, T> transformer) {
            this.source = source;
            this.transformer = transformer;
        }

        @Override
        public boolean hasNext() {
            return source.hasNext();
        }

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

    // 6. 合并迭代器 (多个有序集合的合并)
    public static class MergingIterator<T> implements Iterator<T> {
        private final PriorityQueue<PeekingIterator<T>> heap;
        private final Comparator<T> comparator;

        public MergingIterator(List<Iterator<T>> iterators, Comparator<T> comparator) {
            this.comparator = comparator;
            this.heap = new PriorityQueue<>(iterators.size(),
                    Comparator.comparing((PeekingIterator<T> it) -> it.peek(), comparator));

            for (Iterator<T> iterator : iterators) {
                if (iterator.hasNext()) {
                    heap.offer(new PeekingIterator<>(iterator));
                }
            }
        }

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

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

            PeekingIterator<T> iterator = heap.poll();
            T result = iterator.next();

            if (iterator.hasNext()) {
                heap.offer(iterator);
            }

            return result;
        }

        private static class PeekingIterator<T> {
            private final Iterator<T> iterator;
            private T nextValue;

            public PeekingIterator(Iterator<T> iterator) {
                this.iterator = iterator;
                this.nextValue = iterator.hasNext() ? iterator.next() : null;
            }

            public T peek() {
                return nextValue;
            }

            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                T result = nextValue;
                nextValue = iterator.hasNext() ? iterator.next() : null;
                return result;
            }

            public boolean hasNext() {
                return nextValue != null;
            }
        }
    }

    // 示例使用和测试
    public static void demonstrateCustomIterators() {
        System.out.println("=== 自定义迭代器演示 ===");

        // 1. 二叉树遍历
        System.out.println("\n--- 二叉树遍历 ---");
        TreeNode<Integer> root = new TreeNode<>(1,
                new TreeNode<>(2,
                        new TreeNode<>(4),
                        new TreeNode<>(5)),
                new TreeNode<>(3,
                        new TreeNode<>(6),
                        new TreeNode<>(7)));

        System.out.println("中序遍历:");
        InOrderIterator<Integer> inOrder = new InOrderIterator<>(root);
        while (inOrder.hasNext()) {
            System.out.print(inOrder.next() + " ");
        }

        System.out.println("\n前序遍历:");
        PreOrderIterator<Integer> preOrder = new PreOrderIterator<>(root);
        while (preOrder.hasNext()) {
            System.out.print(preOrder.next() + " ");
        }

        System.out.println("\n层序遍历:");
        LevelOrderIterator<Integer> levelOrder = new LevelOrderIterator<>(root);
        while (levelOrder.hasNext()) {
            System.out.print(levelOrder.next() + " ");
        }

        // 2. 图遍历
        System.out.println("\n\n--- 图遍历 ---");
        GraphNode<String> a = new GraphNode<>("A");
        GraphNode<String> b = new GraphNode<>("B");
        GraphNode<String> c = new GraphNode<>("C");
        GraphNode<String> d = new GraphNode<>("D");
        GraphNode<String> e = new GraphNode<>("E");

        a.addNeighbor(b);
        a.addNeighbor(c);
        b.addNeighbor(d);
        c.addNeighbor(d);
        d.addNeighbor(e);

        System.out.println("深度优先遍历:");
        GraphDFSIterator<String> graphIterator = new GraphDFSIterator<>(a);
        while (graphIterator.hasNext()) {
            System.out.print(graphIterator.next() + " ");
        }

        // 3. 分页数据遍历
        System.out.println("\n\n--- 分页数据遍历 ---");
        List<Integer> allData = new ArrayList<>();
        for (int i = 1; i <= 23; i++) {
            allData.add(i);
        }
        PaginationDataSource<Integer> dataSource = new PaginationDataSource<>(allData, 5);
        PaginationIterator<Integer> paginationIterator = new PaginationIterator<>(dataSource);

        int count = 0;
        while (paginationIterator.hasNext() && count < 10) {
            System.out.print(paginationIterator.next() + " ");
            count++;
        }

        // 4. 过滤和转换
        System.out.println("\n\n--- 过滤和转换 ---");
        List<String> words = Arrays.asList("Java", "Python", "JavaScript", "Go", "Rust", "C", "Kotlin");

        System.out.println("过滤长度 >= 4:");
        FilterIterator<String> filterIterator = new FilterIterator<>(
                words.iterator(), s -> s.length() >= 4);
        while (filterIterator.hasNext()) {
            System.out.print(filterIterator.next() + " ");
        }

        System.out.println("\n转换为大写:");
        TransformIterator<String, String> transformIterator = new TransformIterator<>(
                words.iterator(), String::toUpperCase);
        while (transformIterator.hasNext()) {
            System.out.print(transformIterator.next() + " ");
        }

        // 5. 合并有序集合
        System.out.println("\n\n--- 合并有序集合 ---");
        List<Integer> list1 = Arrays.asList(1, 3, 5, 7, 9);
        List<Integer> list2 = Arrays.asList(2, 4, 6, 8, 10);
        List<Integer> list3 = Arrays.asList(0, 11, 12, 13);

        List<Iterator<Integer>> iterators = Arrays.asList(
                list1.iterator(), list2.iterator(), list3.iterator());

        MergingIterator<Integer> mergingIterator = new MergingIterator<>(iterators, Integer::compareTo);

        System.out.println("合并后的有序序列:");
        while (mergingIterator.hasNext()) {
            System.out.print(mergingIterator.next() + " ");
        }
    }

    public static void main(String[] args) {
        demonstrateCustomIterators();
    }
}

---

⚡ 迭代器性能优化指南

1. 迭代器选择策略

public class IteratorPerformanceOptimization {

    // 不同迭代方式的性能对比
    public static void compareIterationMethods() {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) {
            list.add(i);
        }

        int iterations = 100;

        // 1. 传统 for 循环
        long startTime = System.nanoTime();
        for (int iter = 0; iter < iterations; iter++) {
            for (int i = 0; i < list.size(); i++) {
                Integer value = list.get(i);
                // 简单处理
            }
        }
        long forLoopTime = System.nanoTime() - startTime;

        // 2. 增强 for 循环
        startTime = System.nanoTime();
        for (int iter = 0; iter < iterations; iter++) {
            for (Integer value : list) {
                // 简单处理
            }
        }
        long forEachTime = System.nanoTime() - startTime;

        // 3. Iterator 显式迭代
        startTime = System.nanoTime();
        for (int iter = 0; iter < iterations; iter++) {
            Iterator<Integer> iterator = list.iterator();
            while (iterator.hasNext()) {
                Integer value = iterator.next();
                // 简单处理
            }
        }
        long iteratorTime = System.nanoTime() - startTime;

        // 4. Stream API
        startTime = System.nanoTime();
        for (int iter = 0; iter < iterations; iter++) {
            list.stream().forEach(value -> {
                // 简单处理
            });
        }
        long streamTime = System.nanoTime() - startTime;

        // 5. 并行 Stream
        startTime = System.nanoTime();
        for (int iter = 0; iter < iterations; iter++) {
            list.parallelStream().forEach(value -> {
                // 简单处理
            });
        }
        long parallelStreamTime = System.nanoTime() - startTime;

        System.out.println("=== 迭代方式性能对比 ===");
        System.out.printf("传统 for 循环: %.2f ms%n", forLoopTime / 1_000_000.0);
        System.out.printf("增强 for 循环: %.2f ms%n", forEachTime / 1_000_000.0);
        System.out.printf("Iterator 显式迭代: %.2f ms%n", iteratorTime / 1_000_000.0);
        System.out.printf("Stream API: %.2f ms%n", streamTime / 1_000_000.0);
        System.out.printf("并行 Stream API: %.2f ms%n", parallelStreamTime / 1_000_000.0);
    }

    // 2. 批量处理优化
    public static class BatchProcessor<T> {
        private final Iterator<T> source;
        private final int batchSize;
        private final Consumer<List<T>> batchConsumer;

        public BatchProcessor(Iterator<T> source, int batchSize, Consumer<List<T>> batchConsumer) {
            this.source = source;
            this.batchSize = batchSize;
            this.batchConsumer = batchConsumer;
        }

        public void process() {
            List<T> batch = new ArrayList<>(batchSize);

            while (source.hasNext()) {
                batch.add(source.next());

                if (batch.size() >= batchSize) {
                    batchConsumer.accept(new ArrayList<>(batch));
                    batch.clear();
                }
            }

            if (!batch.isEmpty()) {
                batchConsumer.accept(batch);
            }
        }
    }

    // 3. 缓存迭代器（避免重复计算）
    public static class CachingIterator<T> implements Iterator<T> {
        private final Supplier<T> supplier;
        private final Queue<T> cache = new ArrayDeque<>();
        private boolean exhausted = false;

        public CachingIterator(Supplier<T> supplier) {
            this.supplier = supplier;
        }

        @Override
        public boolean hasNext() {
            if (!cache.isEmpty()) {
                return true;
            }

            if (exhausted) {
                return false;
            }

            try {
                T next = supplier.get();
                if (next != null) {
                    cache.offer(next);
                    return true;
                } else {
                    exhausted = true;
                    return false;
                }
            } catch (Exception e) {
                exhausted = true;
                return false;
            }
        }

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

        public void prefetch(int count) {
            while (cache.size() < count && hasNext()) {
                // hasNext() 会自动填充缓存
            }
        }

        public int cacheSize() {
            return cache.size();
        }
    }

    // 4. 惰性迭代器（延迟计算）
    public static class LazyIterator<T> implements Iterator<T> {
        private final Supplier<Optional<T>> supplier;
        private Optional<T> nextValue;

        public LazyIterator(Supplier<Optional<T>> supplier) {
            this.supplier = supplier;
            advance();
        }

        private void advance() {
            nextValue = supplier.get();
        }

        @Override
        public boolean hasNext() {
            return nextValue.isPresent();
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            T result = nextValue.get();
            advance();
            return result;
        }
    }

    // 5. 内存效率优化
    public static class MemoryEfficientIterator<T> implements Iterator<T>, Closeable {
        private final InputStream inputStream;
        private final Function<byte[], T> deserializer;
        private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
        private byte[] lineBuffer = new byte[1024];
        private String nextLine;
        private boolean closed = false;

        public MemoryEfficientIterator(InputStream inputStream, Function<byte[], T> deserializer) {
            this.inputStream = inputStream;
            this.deserializer = deserializer;
            readNextLine();
        }

        private void readNextLine() {
            try {
                int read;
                buffer.reset();

                while ((read = inputStream.read(lineBuffer)) != -1) {
                    for (int i = 0; i < read; i++) {
                        byte b = lineBuffer[i];
                        if (b == '\n') {
                            nextLine = new String(buffer.toByteArray(), "UTF-8");
                            return;
                        } else {
                            buffer.write(b);
                        }
                    }
                }

                if (buffer.size() > 0) {
                    nextLine = new String(buffer.toByteArray(), "UTF-8");
                } else {
                    nextLine = null;
                }
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        @Override
        public boolean hasNext() {
            return nextLine != null && !closed;
        }

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

            String line = nextLine;
            readNextLine();

            return deserializer.apply(line.getBytes());
        }

        @Override
        public void close() throws IOException {
            if (!closed) {
                inputStream.close();
                closed = true;
            }
        }
    }

    // 使用示例
    public static void demonstrateOptimizations() {
        // 1. 基础性能测试
        compareIterationMethods();

        // 2. 批量处理示例
        System.out.println("\n=== 批量处理示例 ===");
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 25; i++) {
            numbers.add(i);
        }

        AtomicInteger sum = new AtomicInteger(0);
        AtomicInteger batchCount = new AtomicInteger(0);

        BatchProcessor<Integer> processor = new BatchProcessor<>(
                numbers.iterator(),
                5,  // 批量大小
                batch -> {
                    int batchSum = batch.stream().mapToInt(Integer::intValue).sum();
                    sum.addAndGet(batchSum);
                    System.out.printf("处理批次 %d: %s (和: %d)%n",
                            batchCount.incrementAndGet(), batch, batchSum);
                });

        processor.process();
        System.out.println("总和: " + sum.get());

        // 3. 缓存迭代器示例
        System.out.println("\n=== 缓存迭代器示例 ===");
        AtomicInteger counter = new AtomicInteger(0);
        CachingIterator<Integer> cachingIterator = new CachingIterator<>(() -> {
            int value = counter.getAndIncrement();
            return value <= 10 ? value : null;
        });

        System.out.println("预取前缓存大小: " + cachingIterator.cacheSize());
        cachingIterator.prefetch(5);
        System.out.println("预取后缓存大小: " + cachingIterator.cacheSize());

        while (cachingIterator.hasNext()) {
            System.out.print(cachingIterator.next() + " ");
        }

        // 4. 惰性迭代器示例
        System.out.println("\n\n=== 惰性迭代器示例 ===");
        LazyIterator<Integer> lazyIterator = new LazyIterator<>(() -> {
            int value = (int) (Math.random() * 100);
            System.out.println("生成值: " + value);
            return Optional.of(value);
        });

        for (int i = 0; i < 5 && lazyIterator.hasNext(); i++) {
            System.out.println("获取: " + lazyIterator.next());
        }
    }

    public static void main(String[] args) {
        demonstrateOptimizations();
    }
}

---

📚 Iterator 面试通关清单

🎯 基础概念 (必须掌握)

• 迭代器模式的核心思想和优势
• Iterator 接口的基本方法
• Iterable 接口与 for-each 循环的关系
• 增强 for 循环的内部实现原理

🚀 进阶知识 (面试加分)

• Fail-Fast 机制的工作原理
• Fail-Safe 机制与内存开销
• ListIterator 双向迭代器的使用
• Spliterator 并行迭代器的原理
• 迭代器的设计模式和实现

🔧 实战能力 (项目应用)

• 为自定义数据结构实现迭代器
• 性能优化技巧和最佳实践
• 并发环境下的迭代器选择
• 流式处理和函数式编程中的应用
• 内存敏感场景下的迭代器优化

---

💎 总结

Iterator 作为 Java 集合框架的核心组件，在数据访问和遍历方面发挥着不可替代的作用：

核心要点回顾：

• 🎯 设计模式价值：统一访问接口、封装内部结构、支持多种遍历方式
• 🔒 Fail-Fast 机制：快速检测并发修改，适用于单线程或同步环境
• 🔄 Fail-Safe 机制：线程安全但内存开销高，适用于读多写少场景
• 🚀 Spliterator 并行迭代：Java 8+ 的并行处理利器，充分利用多核优势
• 🔧 自定义迭代器：为复杂数据结构提供统一遍历接口

实战建议：

1. 单线程环境：优先使用 Fail-Fast 迭代器，性能好且内存效率高
2. 多线程环境：使用 CopyOnWriteArrayList 等线程安全集合的迭代器
3. 并行处理：使用 Spliterator 和 Stream API 充分利用多核性能
4. 内存敏感：避免过度使用 Fail-Safe 迭代器，注意内存开销
5. 自定义结构：实现合适的迭代器接口，提供统一的遍历方式
6. 性能优化：根据数据特点选择最优的迭代方式和批量处理策略

掌握了这些知识点，你就可以在面试和实际开发中游刃有余地使用 Iterator 了！🚀

学习建议：先掌握基础的 Iterator 接口和 Fail-Fast 机制，再学习 ListIterator 和 Spliterator，最后理解如何为自定义数据结构实现迭代器。重点关注并发安全和性能优化的权衡。

记住：好的迭代器设计是优秀集合实现的关键！选择合适的迭代策略比算法优化更重要！