🎯 模式定义与核心思想

迭代子模式（Iterator Pattern）是一种行为型设计模式，它提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

核心哲学

“封装遍历逻辑，分离集合结构与遍历算法，实现透明访问”

🏗️ 基础架构与角色分析

模式结构组成

角色	职责	示例
迭代器接口	定义遍历操作的基本方法	Iterator
具体迭代器	实现迭代器接口，维护遍历位置	ConcreteIterator
聚合接口	定义创建迭代器的方法	Aggregate
具体聚合	实现聚合接口，返回具体迭代器	ConcreteAggregate

💻 完整代码示例：集合遍历系统

基础迭代子模式实现

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

// 聚合接口
public interface Aggregate<T> {
    Iterator<T> createIterator();
    int size();
    boolean isEmpty();
    void add(T element);
    void remove(T element);
}

// 具体迭代器 - 数组迭代器
public class ArrayIterator<T> implements Iterator<T> {
    private final T[] array;
    private int position;
    private final int size;
    
    public ArrayIterator(T[] array, int size) {
        this.array = array;
        this.size = size;
        this.position = 0;
    }
    
    @Override
    public boolean hasNext() {
        return position < size;
    }
    
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException("没有更多元素");
        }
        return array[position++];
    }
    
    @Override
    public void remove() {
        throw new UnsupportedOperationException("数组迭代器不支持删除操作");
    }
    
    @Override
    public void reset() {
        position = 0;
    }
    
    @Override
    public int getPosition() {
        return position;
    }
    
    // 额外功能：向前看一个元素
    public T peek() {
        if (!hasNext()) {
            return null;
        }
        return array[position];
    }
    
    // 跳转到指定位置
    public void jumpTo(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界: " + index);
        }
        position = index;
    }
}

// 具体聚合 - 数组集合
public class ArrayCollection<T> implements Aggregate<T> {
    private static final int DEFAULT_CAPACITY = 10;
    private T[] elements;
    private int size;
    
    @SuppressWarnings("unchecked")
    public ArrayCollection() {
        this.elements = (T[]) new Object[DEFAULT_CAPACITY];
        this.size = 0;
    }
    
    @SuppressWarnings("unchecked")
    public ArrayCollection(int initialCapacity) {
        this.elements = (T[]) new Object[initialCapacity];
        this.size = 0;
    }
    
    @Override
    public Iterator<T> createIterator() {
        return new ArrayIterator<>(elements, size);
    }
    
    @Override
    public int size() {
        return size;
    }
    
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    
    @Override
    public void add(T element) {
        ensureCapacity();
        elements[size++] = element;
    }
    
    @Override
    public void remove(T element) {
        for (int i = 0; i < size; i++) {
            if (Objects.equals(elements[i], element)) {
                // 移动后续元素
                System.arraycopy(elements, i + 1, elements, i, size - i - 1);
                elements[--size] = null;
                return;
            }
        }
    }
    
    @SuppressWarnings("unchecked")
    private void ensureCapacity() {
        if (size == elements.length) {
            int newCapacity = elements.length * 2;
            T[] newElements = (T[]) new Object[newCapacity];
            System.arraycopy(elements, 0, newElements, 0, size);
            elements = newElements;
            System.out.println("📦 数组扩容: " + elements.length + " -> " + newCapacity);
        }
    }
    
    // 获取指定位置的元素
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("索引越界: " + index);
        }
        return elements[index];
    }
    
    // 转换为数组
    public T[] toArray() {
        return Arrays.copyOf(elements, size);
    }
    
    // 清空集合
    public void clear() {
        Arrays.fill(elements, 0, size, null);
        size = 0;
    }
}

// 具体迭代器 - 链表迭代器
public class LinkedListIterator<T> implements Iterator<T> {
    private final LinkedListCollection<T>.Node head;
    private LinkedListCollection<T>.Node current;
    private int position;
    
    public LinkedListIterator(LinkedListCollection<T>.Node head) {
        this.head = head;
        this.current = head;
        this.position = 0;
    }
    
    @Override
    public boolean hasNext() {
        return current != null;
    }
    
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException("没有更多元素");
        }
        T data = current.data;
        current = current.next;
        position++;
        return data;
    }
    
    @Override
    public void remove() {
        throw new UnsupportedOperationException("链表迭代器不支持删除操作");
    }
    
    @Override
    public void reset() {
        current = head;
        position = 0;
    }
    
    @Override
    public int getPosition() {
        return position;
    }
    
    // 获取当前节点（不移动指针）
    public T current() {
        return current != null ? current.data : null;
    }
}

// 具体聚合 - 链表集合
public class LinkedListCollection<T> implements Aggregate<T> {
    // 链表节点
    public class Node {
        T data;
        Node next;
        
        Node(T data) {
            this.data = data;
            this.next = null;
        }
    }
    
    private Node head;
    private Node tail;
    private int size;
    
    public LinkedListCollection() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }
    
    @Override
    public Iterator<T> createIterator() {
        return new LinkedListIterator<>(head);
    }
    
    @Override
    public int size() {
        return size;
    }
    
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    
    @Override
    public void add(T element) {
        Node newNode = new Node(element);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }
    
    @Override
    public void remove(T element) {
        if (head == null) return;
        
        // 处理头节点
        if (Objects.equals(head.data, element)) {
            head = head.next;
            if (head == null) tail = null;
            size--;
            return;
        }
        
        // 处理中间和尾部节点
        Node current = head;
        while (current.next != null) {
            if (Objects.equals(current.next.data, element)) {
                current.next = current.next.next;
                if (current.next == null) {
                    tail = current;
                }
                size--;
                return;
            }
            current = current.next;
        }
    }
    
    // 在头部添加元素
    public void addFirst(T element) {
        Node newNode = new Node(element);
        newNode.next = head;
        head = newNode;
        if (tail == null) {
            tail = newNode;
        }
        size++;
    }
    
    // 获取头部元素
    public T getFirst() {
        if (head == null) {
            throw new NoSuchElementException("链表为空");
        }
        return head.data;
    }
    
    // 获取尾部元素
    public T getLast() {
        if (tail == null) {
            throw new NoSuchElementException("链表为空");
        }
        return tail.data;
    }
}

// 具体迭代器 - 二叉树迭代器（中序遍历）
public class BinaryTreeIterator<T> implements Iterator<T> {
    private final BinaryTreeCollection<T> tree;
    private java.util.Iterator<T> internalIterator;
    
    public BinaryTreeIterator(BinaryTreeCollection<T> tree) {
        this.tree = tree;
        this.internalIterator = tree.inOrderTraversal().iterator();
    }
    
    @Override
    public boolean hasNext() {
        return internalIterator.hasNext();
    }
    
    @Override
    public T next() {
        return internalIterator.next();
    }
    
    @Override
    public void remove() {
        throw new UnsupportedOperationException("二叉树迭代器不支持删除操作");
    }
    
    @Override
    public void reset() {
        this.internalIterator = tree.inOrderTraversal().iterator();
    }
    
    @Override
    public int getPosition() {
        throw new UnsupportedOperationException("二叉树迭代器不支持位置查询");
    }
}

// 具体聚合 - 二叉树集合
public class BinaryTreeCollection<T extends Comparable<T>> implements Aggregate<T> {
    // 二叉树节点
    private class TreeNode {
        T data;
        TreeNode left;
        TreeNode right;
        
        TreeNode(T data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    }
    
    private TreeNode root;
    private int size;
    
    public BinaryTreeCollection() {
        this.root = null;
        this.size = 0;
    }
    
    @Override
    public Iterator<T> createIterator() {
        return new BinaryTreeIterator<>(this);
    }
    
    @Override
    public int size() {
        return size;
    }
    
    @Override
    public boolean isEmpty() {
        return size == 0;
    }
    
    @Override
    public void add(T element) {
        root = insert(root, element);
        size++;
    }
    
    @Override
    public void remove(T element) {
        root = delete(root, element);
        size--;
    }
    
    private TreeNode insert(TreeNode node, T element) {
        if (node == null) {
            return new TreeNode(element);
        }
        
        int cmp = element.compareTo(node.data);
        if (cmp < 0) {
            node.left = insert(node.left, element);
        } else if (cmp > 0) {
            node.right = insert(node.right, element);
        }
        
        return node;
    }
    
    private TreeNode delete(TreeNode node, T element) {
        if (node == null) return null;
        
        int cmp = element.compareTo(node.data);
        if (cmp < 0) {
            node.left = delete(node.left, element);
        } else if (cmp > 0) {
            node.right = delete(node.right, element);
        } else {
            // 找到要删除的节点
            if (node.left == null) return node.right;
            if (node.right == null) return node.left;
            
            // 有两个子节点，找到右子树的最小值
            TreeNode minNode = findMin(node.right);
            node.data = minNode.data;
            node.right = delete(node.right, minNode.data);
        }
        
        return node;
    }
    
    private TreeNode findMin(TreeNode node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }
    
    // 中序遍历
    public List<T> inOrderTraversal() {
        List<T> result = new ArrayList<>();
        inOrderTraversal(root, result);
        return result;
    }
    
    private void inOrderTraversal(TreeNode node, List<T> result) {
        if (node != null) {
            inOrderTraversal(node.left, result);
            result.add(node.data);
            inOrderTraversal(node.right, result);
        }
    }
    
    // 前序遍历
    public List<T> preOrderTraversal() {
        List<T> result = new ArrayList<>();
        preOrderTraversal(root, result);
        return result;
    }
    
    private void preOrderTraversal(TreeNode node, List<T> result) {
        if (node != null) {
            result.add(node.data);
            preOrderTraversal(node.left, result);
            preOrderTraversal(node.right, result);
        }
    }
    
    // 后序遍历
    public List<T> postOrderTraversal() {
        List<T> result = new ArrayList<>();
        postOrderTraversal(root, result);
        return result;
    }
    
    private void postOrderTraversal(TreeNode node, List<T> result) {
        if (node != null) {
            postOrderTraversal(node.left, result);
            postOrderTraversal(node.right, result);
            result.add(node.data);
        }
    }
}

// 迭代器工具类
public class IteratorUtils {
    
    // 遍历并处理每个元素
    public static <T> void forEach(Iterator<T> iterator, Consumer<T> action) {
        while (iterator.hasNext()) {
            action.accept(iterator.next());
        }
    }
    
    // 转换为List
    public static <T> List<T> toList(Iterator<T> iterator) {
        List<T> list = new ArrayList<>();
        forEach(iterator, list::add);
        return list;
    }
    
    // 过滤元素
    public static <T> Iterator<T> filter(Iterator<T> iterator, Predicate<T> predicate) {
        return new Iterator<T>() {
            private T nextElement = findNext();
            
            private T findNext() {
                while (iterator.hasNext()) {
                    T element = iterator.next();
                    if (predicate.test(element)) {
                        return element;
                    }
                }
                return null;
            }
            
            @Override
            public boolean hasNext() {
                return nextElement != null;
            }
            
            @Override
            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                T result = nextElement;
                nextElement = findNext();
                return result;
            }
            
            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
            
            @Override
            public void reset() {
                iterator.reset();
                nextElement = findNext();
            }
            
            @Override
            public int getPosition() {
                return iterator.getPosition();
            }
        };
    }
    
    // 映射元素
    public static <T, R> Iterator<R> map(Iterator<T> iterator, Function<T, R> mapper) {
        return new Iterator<R>() {
            @Override
            public boolean hasNext() {
                return iterator.hasNext();
            }
            
            @Override
            public R next() {
                return mapper.apply(iterator.next());
            }
            
            @Override
            public void remove() {
                iterator.remove();
            }
            
            @Override
            public void reset() {
                iterator.reset();
            }
            
            @Override
            public int getPosition() {
                return iterator.getPosition();
            }
        };
    }
    
    // 限制元素数量
    public static <T> Iterator<T> limit(Iterator<T> iterator, int maxSize) {
        return new Iterator<T>() {
            private int count = 0;
            
            @Override
            public boolean hasNext() {
                return iterator.hasNext() && count < maxSize;
            }
            
            @Override
            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                count++;
                return iterator.next();
            }
            
            @Override
            public void remove() {
                iterator.remove();
            }
            
            @Override
            public void reset() {
                iterator.reset();
                count = 0;
            }
            
            @Override
            public int getPosition() {
                return iterator.getPosition();
            }
        };
    }
}

// 客户端演示
public class IteratorPatternDemo {
    public static void main(String[] args) {
        System.out.println("=== 迭代子模式演示：集合遍历系统 ===\n");
        
        // 1. 数组集合演示
        System.out.println("1. 数组集合遍历演示:");
        ArrayCollection<String> arrayCollection = new ArrayCollection<>();
        arrayCollection.add("Apple");
        arrayCollection.add("Banana");
        arrayCollection.add("Cherry");
        arrayCollection.add("Date");
        
        System.out.println("数组集合大小: " + arrayCollection.size());
        iterateCollection("数组集合", arrayCollection);
        
        // 2. 链表集合演示
        System.out.println("\n2. 链表集合遍历演示:");
        LinkedListCollection<Integer> linkedList = new LinkedListCollection<>();
        linkedList.add(10);
        linkedList.add(20);
        linkedList.add(30);
        linkedList.addFirst(5); // 在头部添加
        
        System.out.println("链表集合大小: " + linkedList.size());
        iterateCollection("链表集合", linkedList);
        
        // 3. 二叉树集合演示
        System.out.println("\n3. 二叉树集合遍历演示:");
        BinaryTreeCollection<Integer> binaryTree = new BinaryTreeCollection<>();
        binaryTree.add(50);
        binaryTree.add(30);
        binaryTree.add(70);
        binaryTree.add(20);
        binaryTree.add(40);
        binaryTree.add(60);
        binaryTree.add(80);
        
        System.out.println("二叉树集合大小: " + binaryTree.size());
        iterateCollection("二叉树集合", binaryTree);
        
        // 4. 迭代器工具演示
        System.out.println("\n4. 迭代器工具演示:");
        demonstrateIteratorUtils();
        
        // 5. 性能对比
        System.out.println("\n5. 性能对比演示:");
        performanceComparison();
    }
    
    private static <T> void iterateCollection(String name, Aggregate<T> collection) {
        System.out.println("🔹 " + name + " 遍历:");
        
        Iterator<T> iterator = collection.createIterator();
        int count = 0;
        
        while (iterator.hasNext()) {
            T element = iterator.next();
            System.out.println("  位置 " + iterator.getPosition() + ": " + element);
            count++;
        }
        
        System.out.println("✅ 共遍历 " + count + " 个元素");
        
        // 重置迭代器再次遍历
        iterator.reset();
        System.out.println("🔄 重置迭代器后再次遍历:");
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
    }
    
    private static void demonstrateIteratorUtils() {
        ArrayCollection<Integer> numbers = new ArrayCollection<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }
        
        // 使用工具类进行函数式操作
        System.out.println("原始数据: " + IteratorUtils.toList(numbers.createIterator()));
        
        // 过滤偶数
        Iterator<Integer> evenIterator = IteratorUtils.filter(
            numbers.createIterator(), n -> n % 2 == 0
        );
        System.out.println("偶数: " + IteratorUtils.toList(evenIterator));
        
        // 映射为平方
        Iterator<Integer> squaredIterator = IteratorUtils.map(
            numbers.createIterator(), n -> n * n
        );
        System.out.println("平方: " + IteratorUtils.toList(squaredIterator));
        
        // 限制数量
        Iterator<Integer> limitedIterator = IteratorUtils.limit(
            numbers.createIterator(), 3
        );
        System.out.println("前3个: " + IteratorUtils.toList(limitedIterator));
        
        // 组合操作：过滤偶数 -> 映射为平方 -> 限制数量
        Iterator<Integer> complexIterator = IteratorUtils.limit(
            IteratorUtils.map(
                IteratorUtils.filter(
                    numbers.createIterator(), 
                    n -> n % 2 == 0
                ),
                n -> n * n
            ),
            2
        );
        System.out.println("前2个偶数的平方: " + IteratorUtils.toList(complexIterator));
    }
    
    private static void performanceComparison() {
        int size = 10000;
        
        // 数组集合性能测试
        ArrayCollection<Integer> arrayCollection = new ArrayCollection<>();
        for (int i = 0; i < size; i++) {
            arrayCollection.add(i);
        }
        
        long startTime = System.nanoTime();
        Iterator<Integer> arrayIterator = arrayCollection.createIterator();
        while (arrayIterator.hasNext()) {
            arrayIterator.next();
        }
        long arrayTime = System.nanoTime() - startTime;
        
        // 链表集合性能测试
        LinkedListCollection<Integer> linkedList = new LinkedListCollection<>();
        for (int i = 0; i < size; i++) {
            linkedList.add(i);
        }
        
        startTime = System.nanoTime();
        Iterator<Integer> linkedListIterator = linkedList.createIterator();
        while (linkedListIterator.hasNext()) {
            linkedListIterator.next();
        }
        long linkedListTime = System.nanoTime() - startTime;
        
        System.out.println("遍历 " + size + " 个元素的性能对比:");
        System.out.println("数组集合: " + arrayTime + " ns");
        System.out.println("链表集合: " + linkedListTime + " ns");
        System.out.println("性能差异: " + (linkedListTime - arrayTime) + " ns");
    }
}

🏢 企业级应用：文件系统遍历

复杂的迭代子模式实现

// 文件系统条目接口
public interface FileSystemItem {
    String getName();
    long getSize();
    boolean isDirectory();
    String getPath();
    Date getLastModified();
}

// 具体文件系统条目
public class FileItem implements FileSystemItem {
    private final String name;
    private final long size;
    private final String path;
    private final Date lastModified;
    
    public FileItem(String name, long size, String path) {
        this.name = name;
        this.size = size;
        this.path = path;
        this.lastModified = new Date();
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    @Override
    public long getSize() {
        return size;
    }
    
    @Override
    public boolean isDirectory() {
        return false;
    }
    
    @Override
    public String getPath() {
        return path;
    }
    
    @Override
    public Date getLastModified() {
        return lastModified;
    }
    
    @Override
    public String toString() {
        return String.format("📄 %s (%d bytes)", name, size);
    }
}

public class DirectoryItem implements FileSystemItem {
    private final String name;
    private final String path;
    private final Date lastModified;
    private final List<FileSystemItem> children;
    
    public DirectoryItem(String name, String path) {
        this.name = name;
        this.path = path;
        this.lastModified = new Date();
        this.children = new ArrayList<>();
    }
    
    public void addChild(FileSystemItem item) {
        children.add(item);
    }
    
    public void removeChild(FileSystemItem item) {
        children.remove(item);
    }
    
    public List<FileSystemItem> getChildren() {
        return new ArrayList<>(children);
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    @Override
    public long getSize() {
        return children.stream().mapToLong(FileSystemItem::getSize).sum();
    }
    
    @Override
    public boolean isDirectory() {
        return true;
    }
    
    @Override
    public String getPath() {
        return path;
    }
    
    @Override
    public Date getLastModified() {
        return lastModified;
    }
    
    @Override
    public String toString() {
        return String.format("📁 %s (%d items)", name, children.size());
    }
}

// 文件系统迭代器接口
public interface FileSystemIterator extends Iterator<FileSystemItem> {
    String getCurrentPath();
    int getDepth();
    boolean isRecursive();
    void setFilter(Predicate<FileSystemItem> filter);
}

// 具体迭代器 - 深度优先遍历
public class DepthFirstFileIterator implements FileSystemIterator {
    private final Stack<IteratorContext> stack;
    private final boolean recursive;
    private Predicate<FileSystemItem> filter;
    private FileSystemItem current;
    private int position;
    
    private static class IteratorContext {
        final FileSystemItem item;
        final Iterator<FileSystemItem> iterator;
        final int depth;
        
        IteratorContext(FileSystemItem item, Iterator<FileSystemItem> iterator, int depth) {
            this.item = item;
            this.iterator = iterator;
            this.depth = depth;
        }
    }
    
    public DepthFirstFileIterator(FileSystemItem root, boolean recursive) {
        this.stack = new Stack<>();
        this.recursive = recursive;
        this.filter = item -> true;
        this.position = 0;
        
        if (root != null) {
            stack.push(new IteratorContext(root, Collections.singletonList(root).iterator(), 0));
        }
    }
    
    @Override
    public boolean hasNext() {
        while (!stack.isEmpty()) {
            IteratorContext context = stack.peek();
            
            if (context.iterator.hasNext()) {
                FileSystemItem item = context.iterator.next();
                
                if (item.isDirectory() && recursive) {
                    // 如果是目录且递归遍历，将其子项加入栈
                    DirectoryItem dir = (DirectoryItem) item;
                    stack.push(new IteratorContext(dir, dir.getChildren().iterator(), context.depth + 1));
                }
                
                if (filter.test(item)) {
                    current = item;
                    return true;
                }
            } else {
                stack.pop();
            }
        }
        return false;
    }
    
    @Override
    public FileSystemItem next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        position++;
        return current;
    }
    
    @Override
    public void remove() {
        throw new UnsupportedOperationException("文件系统迭代器不支持删除操作");
    }
    
    @Override
    public void reset() {
        stack.clear();
        position = 0;
        // 需要重新初始化，这里简化处理
    }
    
    @Override
    public int getPosition() {
        return position;
    }
    
    @Override
    public String getCurrentPath() {
        return current != null ? current.getPath() : "";
    }
    
    @Override
    public int getDepth() {
        return !stack.isEmpty() ? stack.peek().depth : 0;
    }
    
    @Override
    public boolean isRecursive() {
        return recursive;
    }
    
    @Override
    public void setFilter(Predicate<FileSystemItem> filter) {
        this.filter = filter != null ? filter : item -> true;
    }
}

// 具体迭代器 - 广度优先遍历
public class BreadthFirstFileIterator implements FileSystemIterator {
    private final Queue<IteratorContext> queue;
    private final boolean recursive;
    private Predicate<FileSystemItem> filter;
    private FileSystemItem current;
    private int position;
    
    private static class IteratorContext {
        final FileSystemItem item;
        final int depth;
        
        IteratorContext(FileSystemItem item, int depth) {
            this.item = item;
            this.depth = depth;
        }
    }
    
    public BreadthFirstFileIterator(FileSystemItem root, boolean recursive) {
        this.queue = new LinkedList<>();
        this.recursive = recursive;
        this.filter = item -> true;
        this.position = 0;
        
        if (root != null) {
            queue.offer(new IteratorContext(root, 0));
        }
    }
    
    @Override
    public boolean hasNext() {
        while (!queue.isEmpty()) {
            IteratorContext context = queue.poll();
            FileSystemItem item = context.item;
            
            if (filter.test(item)) {
                current = item;
                
                // 如果是目录且递归遍历，将其子项加入队列
                if (item.isDirectory() && recursive) {
                    DirectoryItem dir = (DirectoryItem) item;
                    for (FileSystemItem child : dir.getChildren()) {
                        queue.offer(new IteratorContext(child, context.depth + 1));
                    }
                }
                
                return true;
            } else if (item.isDirectory() && recursive) {
                // 即使当前目录被过滤，仍然需要处理其子项
                DirectoryItem dir = (DirectoryItem) item;
                for (FileSystemItem child : dir.getChildren()) {
                    queue.offer(new IteratorContext(child, context.depth + 1));
                }
            }
        }
        return false;
    }
    
    @Override
    public FileSystemItem next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        position++;
        return current;
    }
    
    @Override
    public void remove() {
        throw new UnsupportedOperationException("文件系统迭代器不支持删除操作");
    }
    
    @Override
    public void reset() {
        queue.clear();
        position = 0;
        // 需要重新初始化，这里简化处理
    }
    
    @Override
    public int getPosition() {
        return position;
    }
    
    @Override
    public String getCurrentPath() {
        return current != null ? current.getPath() : "";
    }
    
    @Override
    public int getDepth() {
        // 广度优先遍历的深度计算比较复杂，这里简化处理
        return 0;
    }
    
    @Override
    public boolean isRecursive() {
        return recursive;
    }
    
    @Override
    public void setFilter(Predicate<FileSystemItem> filter) {
        this.filter = filter != null ? filter : item -> true;
    }
}

// 文件系统聚合接口
public interface FileSystem extends Aggregate<FileSystemItem> {
    FileSystemIterator createDepthFirstIterator();
    FileSystemIterator createBreadthFirstIterator();
    FileSystemIterator createIterator(boolean recursive, TraversalStrategy strategy);
    FileSystemItem findItem(String path);
    List<FileSystemItem> searchItems(String pattern);
}

// 遍历策略枚举
public enum TraversalStrategy {
    DEPTH_FIRST,
    BREADTH_FIRST
}

// 具体文件系统实现
public class SimpleFileSystem implements FileSystem {
    private final DirectoryItem root;
    
    public SimpleFileSystem(String rootName) {
        this.root = new DirectoryItem(rootName, "/" + rootName);
        initializeSampleData();
    }
    
    private void initializeSampleData() {
        // 创建示例文件系统结构
        DirectoryItem documents = new DirectoryItem("Documents", "/root/Documents");
        documents.addChild(new FileItem("resume.pdf", 2048, "/root/Documents/resume.pdf"));
        documents.addChild(new FileItem("project.docx", 4096, "/root/Documents/project.docx"));
        
        DirectoryItem pictures = new DirectoryItem("Pictures", "/root/Pictures");
        pictures.addChild(new FileItem("photo1.jpg", 1024000, "/root/Pictures/photo1.jpg"));
        pictures.addChild(new FileItem("photo2.png", 2048000, "/root/Pictures/photo2.png"));
        
        DirectoryItem vacation = new DirectoryItem("Vacation", "/root/Pictures/Vacation");
        vacation.addChild(new FileItem("beach.jpg", 3072000, "/root/Pictures/Vacation/beach.jpg"));
        vacation.addChild(new FileItem("mountain.png", 4096000, "/root/Pictures/Vacation/mountain.png"));
        pictures.addChild(vacation);
        
        DirectoryItem code = new DirectoryItem("Code", "/root/Code");
        code.addChild(new FileItem("Main.java", 2048, "/root/Code/Main.java"));
        code.addChild(new FileItem("Utils.java", 1024, "/root/Code/Utils.java"));
        
        root.addChild(documents);
        root.addChild(pictures);
        root.addChild(code);
    }
    
    @Override
    public Iterator<FileSystemItem> createIterator() {
        return createDepthFirstIterator();
    }
    
    @Override
    public FileSystemIterator createDepthFirstIterator() {
        return new DepthFirstFileIterator(root, true);
    }
    
    @Override
    public FileSystemIterator createBreadthFirstIterator() {
        return new BreadthFirstFileIterator(root, true);
    }
    
    @Override
    public FileSystemIterator createIterator(boolean recursive, TraversalStrategy strategy) {
        switch (strategy) {
            case DEPTH_FIRST:
                return new DepthFirstFileIterator(root, recursive);
            case BREADTH_FIRST:
                return new BreadthFirstFileIterator(root, recursive);
            default:
                throw new IllegalArgumentException("不支持的遍历策略: " + strategy);
        }
    }
    
    @Override
    public FileSystemItem findItem(String path) {
        // 简化实现：遍历查找
        FileSystemIterator iterator = createDepthFirstIterator();
        while (iterator.hasNext()) {
            FileSystemItem item = iterator.next();
            if (item.getPath().equals(path)) {
                return item;
            }
        }
        return null;
    }
    
    @Override
    public List<FileSystemItem> searchItems(String pattern) {
        List<FileSystemItem> results = new ArrayList<>();
        FileSystemIterator iterator = createDepthFirstIterator();
        
        iterator.setFilter(item -> 
            item.getName().toLowerCase().contains(pattern.toLowerCase())
        );
        
        while (iterator.hasNext()) {
            results.add(iterator.next());
        }
        
        return results;
    }
    
    @Override
    public int size() {
        int count = 0;
        FileSystemIterator iterator = createDepthFirstIterator();
        while (iterator.hasNext()) {
            iterator.next();
            count++;
        }
        return count;
    }
    
    @Override
    public boolean isEmpty() {
        return root.getChildren().isEmpty();
    }
    
    @Override
    public void add(FileSystemItem element) {
        root.addChild(element);
    }
    
    @Override
    public void remove(FileSystemItem element) {
        root.removeChild(element);
    }
    
    public DirectoryItem getRoot() {
        return root;
    }
}

// 文件系统分析器
public class FileSystemAnalyzer {
    private final FileSystem fileSystem;
    
    public FileSystemAnalyzer(FileSystem fileSystem) {
        this.fileSystem = fileSystem;
    }
    
    public void printFileSystemStructure() {
        System.out.println("=== 文件系统结构 ===");
        FileSystemIterator iterator = fileSystem.createDepthFirstIterator();
        
        while (iterator.hasNext()) {
            FileSystemItem item = iterator.next();
            String indent = "  ".repeat(iterator.getDepth());
            System.out.println(indent + item);
        }
    }
    
    public void analyzeFileSizes() {
        System.out.println("\n=== 文件大小分析 ===");
        FileSystemIterator iterator = fileSystem.createIterator(true, TraversalStrategy.DEPTH_FIRST);
        
        long totalSize = 0;
        int fileCount = 0;
        int directoryCount = 0;
        Map<String, Long> sizeByType = new HashMap<>();
        
        while (iterator.hasNext()) {
            FileSystemItem item = iterator.next();
            
            if (item.isDirectory()) {
                directoryCount++;
            } else {
                fileCount++;
                totalSize += item.getSize();
                
                // 按文件类型统计
                String extension = getFileExtension(item.getName());
                sizeByType.merge(extension, item.getSize(), Long::sum);
            }
        }
        
        System.out.println("文件数量: " + fileCount);
        System.out.println("目录数量: " + directoryCount);
        System.out.println("总大小: " + formatSize(totalSize));
        
        System.out.println("\n按文件类型统计:");
        sizeByType.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .forEach(entry -> 
                    System.out.println("  " + entry.getKey() + ": " + formatSize(entry.getValue()))
                );
    }
    
    public void findLargeFiles(long threshold) {
        System.out.println("\n=== 查找大文件 (>" + formatSize(threshold) + ") ===");
        FileSystemIterator iterator = fileSystem.createIterator(true, TraversalStrategy.DEPTH_FIRST);
        
        iterator.setFilter(item -> !item.isDirectory() && item.getSize() > threshold);
        
        int count = 0;
        while (iterator.hasNext()) {
            FileSystemItem item = iterator.next();
            System.out.println("📁 " + item.getPath() + " - " + formatSize(item.getSize()));
            count++;
        }
        
        System.out.println("找到 " + count + " 个大文件");
    }
    
    public void compareTraversalStrategies() {
        System.out.println("\n=== 遍历策略性能对比 ===");
        
        // 深度优先遍历性能
        long startTime = System.nanoTime();
        FileSystemIterator dfsIterator = fileSystem.createDepthFirstIterator();
        int dfsCount = 0;
        while (dfsIterator.hasNext()) {
            dfsIterator.next();
            dfsCount++;
        }
        long dfsTime = System.nanoTime() - startTime;
        
        // 广度优先遍历性能
        startTime = System.nanoTime();
        FileSystemIterator bfsIterator = fileSystem.createBreadthFirstIterator();
        int bfsCount = 0;
        while (bfsIterator.hasNext()) {
            bfsIterator.next();
            bfsCount++;
        }
        long bfsTime = System.nanoTime() - startTime;
        
        System.out.println("深度优先遍历:");
        System.out.println("  元素数量: " + dfsCount);
        System.out.println("  耗时: " + (dfsTime / 1_000_000.0) + "ms");
        
        System.out.println("广度优先遍历:");
        System.out.println("  元素数量: " + bfsCount);
        System.out.println("  耗时: " + (bfsTime / 1_000_000.0) + "ms");
        
        System.out.println("性能差异: " + ((bfsTime - dfsTime) / 1_000_000.0) + "ms");
    }
    
    private String getFileExtension(String filename) {
        int dotIndex = filename.lastIndexOf('.');
        return dotIndex > 0 ? filename.substring(dotIndex + 1).toLowerCase() : "无扩展名";
    }
    
    private String formatSize(long size) {
        if (size < 1024) return size + " B";
        if (size < 1024 * 1024) return String.format("%.1f KB", size / 1024.0);
        if (size < 1024 * 1024 * 1024) return String.format("%.1f MB", size / (1024.0 * 1024));
        return String.format("%.1f GB", size / (1024.0 * 1024 * 1024));
    }
}

// 文件系统演示
public class FileSystemIteratorDemo {
    public static void main(String[] args) {
        System.out.println("=== 迭代子模式演示：文件系统遍历 ===\n");
        
        // 1. 创建文件系统
        SimpleFileSystem fileSystem = new SimpleFileSystem("root");
        FileSystemAnalyzer analyzer = new FileSystemAnalyzer(fileSystem);
        
        // 2. 打印文件系统结构
        analyzer.printFileSystemStructure();
        
        // 3. 分析文件大小
        analyzer.analyzeFileSizes();
        
        // 4. 查找大文件
        analyzer.findLargeFiles(1024 * 1024); // 1MB
        
        // 5. 比较遍历策略
        analyzer.compareTraversalStrategies();
        
        // 6. 搜索文件
        System.out.println("\n=== 文件搜索演示 ===");
        List<FileSystemItem> searchResults = fileSystem.searchItems("photo");
        System.out.println("搜索 'photo' 结果:");
        searchResults.forEach(item -> System.out.println("  📍 " + item.getPath()));
        
        // 7. 自定义遍历演示
        System.out.println("\n=== 自定义遍历演示 ===");
        demonstrateCustomTraversal(fileSystem);
    }
    
    private static void demonstrateCustomTraversal(FileSystem fileSystem) {
        System.out.println("仅遍历图片文件:");
        FileSystemIterator iterator = fileSystem.createDepthFirstIterator();
        iterator.setFilter(item -> 
            !item.isDirectory() && 
            (item.getName().endsWith(".jpg") || item.getName().endsWith(".png"))
        );
        
        while (iterator.hasNext()) {
            FileSystemItem item = iterator.next();
            System.out.println("  🖼️ " + item.getName() + " - " + item.getPath());
        }
        
        System.out.println("\n仅遍历目录:");
        iterator = fileSystem.createBreadthFirstIterator();
        iterator.setFilter(FileSystemItem::isDirectory);
        
        while (iterator.hasNext()) {
            FileSystemItem item = iterator.next();
            System.out.println("  📁 " + item.getName() + " - " + item.getChildren().size() + " 个子项");
        }
    }
}

由于篇幅限制，我将提供剩余部分的核心内容概述：

🔄 架构演进：从简单到复杂

第一代：基础迭代子模式

第二代：支持泛型和函数式的迭代器

• 泛型迭代器接口：支持类型安全的遍历
• 函数式操作：map、filter、reduce等操作
• 流式API：类似Java Stream的链式调用
• 并行迭代器：支持多线程遍历

第三代：响应式和异步迭代器

• 响应式流：支持背压的异步数据流
• 事件驱动迭代：基于回调的遍历机制
• WebFlux集成：与Spring WebFlux结合的响应式迭代

⚡ 性能优化与缓存策略

高性能迭代器模式

• 懒加载迭代器：按需加载数据，减少内存占用
• 分页迭代器：支持大数据集的分页遍历
• 缓存迭代器：缓存遍历结果，提高重复遍历性能
• 预取迭代器：预先加载后续数据，减少IO等待

🔧 测试策略与验证

迭代子模式测试用例

class IteratorPatternTest {
    @Test
    void testArrayIterator() {
        // 测试数组迭代器基本功能
    }
    
    @Test 
    void testLinkedListIterator() {
        // 测试链表迭代器功能
    }
    
    @Test
    void testBinaryTreeIterator() {
        // 测试二叉树迭代器
    }
    
    @Test
    void testFileSystemIterator() {
        // 测试文件系统迭代器
    }
    
    @Test
    void testIteratorUtils() {
        // 测试迭代器工具类
    }
}

🌐 现代架构中的迭代子模式

Spring Boot中的迭代器应用

• Repository迭代器：Spring Data的分页和流式查询
• 消息队列迭代器：Kafka、RabbitMQ的消息遍历
• 数据库游标：大数据集的结果集迭代
• 微服务数据聚合：跨服务数据集合的统一遍历

📊 模式对比与选择指南

迭代子模式 vs 其他行为型模式

维度	迭代子模式	访问者模式	职责链模式
目的	遍历集合元素	对集合元素执行操作	处理请求的链
关注点	遍历算法	元素操作	请求处理
结构	迭代器+集合	访问者+元素	处理器链
使用时机	需要统一遍历接口	需要对元素执行多种操作	需要处理链

迭代子模式变体对比

类型	优点	缺点	适用场景
内部迭代器	使用简单，代码简洁	控制力弱	简单遍历
外部迭代器	控制力强，灵活	代码复杂	复杂遍历逻辑
懒加载迭代器	内存效率高	实现复杂	大数据集
并行迭代器	性能高	线程安全复杂	多核CPU环境

🎯 最佳实践与陷阱规避

✅ 最佳实践

1. 保持迭代器状态独立：多个迭代器应该互不影响
2. 支持快速失败：在遍历过程中检测集合修改
3. 提供重置功能：允许重新开始遍历
4. 考虑线程安全：在多线程环境中的安全性
5. 清晰的异常处理：明确的越界和修改异常

❌ 常见陷阱

1. 并发修改异常：遍历过程中修改集合
2. 内存泄漏：迭代器持有集合引用导致无法GC
3. 性能问题：不合适的遍历算法导致性能低下
4. 状态不一致：迭代器状态与集合状态不同步

💡 总结升华

迭代子模式是现代软件架构中遍历艺术的精髓，它体现了：

• 封装思想：将遍历逻辑封装在迭代器中
• 单一职责：集合负责存储，迭代器负责遍历
• 开闭原则：可以轻松添加新的遍历算法
• 统一接口：为不同集合提供一致的遍历方式

核心价值：迭代子模式让开发者能够用统一的方式处理各种数据结构的遍历，无论是简单的数组、复杂的树形结构，还是分布式数据源，都能提供一致的遍历体验。