设计模式-迭代器模式详解

迭代器模式详解

迭代器模式简介

定义

迭代器模式（Iterator Pattern）是一种行为型设计模式，它提供一种方法顺序访问一个聚合对象中各个元素，而又无须暴露该对象的内部表示。迭代器模式把在元素之间游走的责任交给迭代器，而不是聚合对象。

核心思想

分离遍历逻辑：将遍历逻辑从聚合对象中分离出来
统一访问接口：为不同的聚合对象提供统一的遍历接口
封装内部结构：隐藏聚合对象的内部实现细节
支持多种遍历：可以同时进行多个遍历操作

模式结构

Iterator（抽象迭代器）：定义访问和遍历元素的接口
ConcreteIterator（具体迭代器）：实现抽象迭代器接口，完成对聚合对象的遍历
Aggregate（抽象聚合类）：定义创建迭代器对象的接口
ConcreteAggregate（具体聚合类）：实现抽象聚合类，返回具体迭代器的实例

核心流程

迭代器模式流程图

聚合对象层次迭代器层次是否 Aggregate接口 ConcreteAggregate实现元素集合 Iterator接口 ConcreteIterator实现聚合对象引用客户端创建聚合对象获取迭代器开始遍历是否有下一个元素? 获取下一个元素遍历结束处理当前元素移动到下一个位置释放资源

基本实现流程

1. 定义抽象迭代器接口

java 复制代码

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

2. 定义抽象聚合类

java 复制代码

// 抽象聚合类
public interface Aggregate<T> {
    Iterator<T> createIterator();
    int size();
    T get(int index);
    void add(T element);
    void remove(T element);
}

3. 实现具体迭代器

java 复制代码

// 具体迭代器
public class ConcreteIterator<T> implements Iterator<T> {
    private Aggregate<T> aggregate;
    private int currentIndex = 0;
  
    public ConcreteIterator(Aggregate<T> aggregate) {
        this.aggregate = aggregate;
    }
  
    @Override
    public boolean hasNext() {
        return currentIndex < aggregate.size();
    }
  
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException("没有更多元素");
        }
        T element = aggregate.get(currentIndex);
        currentIndex++;
        return element;
    }
  
    @Override
    public void remove() {
        if (currentIndex <= 0) {
            throw new IllegalStateException("没有可删除的元素");
        }
        currentIndex--;
        aggregate.remove(aggregate.get(currentIndex));
    }
  
    @Override
    public void reset() {
        currentIndex = 0;
    }
}

4. 实现具体聚合类

java 复制代码

// 具体聚合类
public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> elements = new ArrayList<>();
  
    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(this);
    }
  
    @Override
    public int size() {
        return elements.size();
    }
  
    @Override
    public T get(int index) {
        if (index < 0 || index >= elements.size()) {
            throw new IndexOutOfBoundsException("索引超出范围");
        }
        return elements.get(index);
    }
  
    @Override
    public void add(T element) {
        elements.add(element);
    }
  
    @Override
    public void remove(T element) {
        elements.remove(element);
    }
}

5. 客户端使用

java 复制代码

public class Client {
    public static void main(String[] args) {
        // 创建聚合对象
        Aggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.add("元素1");
        aggregate.add("元素2");
        aggregate.add("元素3");
      
        // 获取迭代器
        Iterator<String> iterator = aggregate.createIterator();
      
        // 遍历元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println("元素: " + element);
        }
      
        // 重置迭代器
        iterator.reset();
      
        // 再次遍历
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println("重新遍历: " + element);
        }
    }
}

重难点分析

重难点1：迭代器的并发安全

问题描述

在多线程环境下，如何确保迭代器的线程安全。

解决方案

java 复制代码

// 线程安全的迭代器
public class ThreadSafeIterator<T> implements Iterator<T> {
    private final List<T> elements;
    private final Object lock = new Object();
    private int currentIndex = 0;
  
    public ThreadSafeIterator(List<T> elements) {
        this.elements = new ArrayList<>(elements);
    }
  
    @Override
    public boolean hasNext() {
        synchronized (lock) {
            return currentIndex < elements.size();
        }
    }
  
    @Override
    public T next() {
        synchronized (lock) {
            if (!hasNext()) {
                throw new NoSuchElementException("没有更多元素");
            }
            T element = elements.get(currentIndex);
            currentIndex++;
            return element;
        }
    }
  
    @Override
    public void remove() {
        synchronized (lock) {
            if (currentIndex <= 0) {
                throw new IllegalStateException("没有可删除的元素");
            }
            currentIndex--;
            elements.remove(currentIndex);
        }
    }
}

// 使用读写锁的迭代器
public class ReadWriteLockIterator<T> implements Iterator<T> {
    private final List<T> elements;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private int currentIndex = 0;
  
    public ReadWriteLockIterator(List<T> elements) {
        this.elements = new ArrayList<>(elements);
    }
  
    @Override
    public boolean hasNext() {
        lock.readLock().lock();
        try {
            return currentIndex < elements.size();
        } finally {
            lock.readLock().unlock();
        }
    }
  
    @Override
    public T next() {
        lock.readLock().lock();
        try {
            if (!hasNext()) {
                throw new NoSuchElementException("没有更多元素");
            }
            T element = elements.get(currentIndex);
            currentIndex++;
            return element;
        } finally {
            lock.readLock().unlock();
        }
    }
  
    @Override
    public void remove() {
        lock.writeLock().lock();
        try {
            if (currentIndex <= 0) {
                throw new IllegalStateException("没有可删除的元素");
            }
            currentIndex--;
            elements.remove(currentIndex);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

重难点2：迭代器的快照机制

问题描述

如何在迭代过程中避免聚合对象修改导致的并发修改异常。

解决方案

java 复制代码

// 快照迭代器
public class SnapshotIterator<T> implements Iterator<T> {
    private final List<T> snapshot;
    private int currentIndex = 0;
  
    public SnapshotIterator(Collection<T> original) {
        this.snapshot = new ArrayList<>(original);
    }
  
    @Override
    public boolean hasNext() {
        return currentIndex < snapshot.size();
    }
  
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException("没有更多元素");
        }
        T element = snapshot.get(currentIndex);
        currentIndex++;
        return element;
    }
  
    @Override
    public void remove() {
        throw new UnsupportedOperationException("快照迭代器不支持删除操作");
    }
}

// 延迟快照迭代器
public class LazySnapshotIterator<T> implements Iterator<T> {
    private final Collection<T> original;
    private List<T> snapshot;
    private int currentIndex = 0;
    private boolean snapshotCreated = false;
  
    public LazySnapshotIterator(Collection<T> original) {
        this.original = original;
    }
  
    private void ensureSnapshot() {
        if (!snapshotCreated) {
            synchronized (original) {
                if (!snapshotCreated) {
                    this.snapshot = new ArrayList<>(original);
                    this.snapshotCreated = true;
                }
            }
        }
    }
  
    @Override
    public boolean hasNext() {
        ensureSnapshot();
        return currentIndex < snapshot.size();
    }
  
    @Override
    public T next() {
        ensureSnapshot();
        if (!hasNext()) {
            throw new NoSuchElementException("没有更多元素");
        }
        T element = snapshot.get(currentIndex);
        currentIndex++;
        return element;
    }
  
    @Override
    public void remove() {
        throw new UnsupportedOperationException("快照迭代器不支持删除操作");
    }
}

重难点3：迭代器的内存管理

问题描述

如何管理迭代器的内存使用，避免内存泄漏。

解决方案

java 复制代码

// 可关闭的迭代器
public class CloseableIterator<T> implements Iterator<T>, AutoCloseable {
    private final Iterator<T> delegate;
    private boolean closed = false;
  
    public CloseableIterator(Iterator<T> delegate) {
        this.delegate = delegate;
    }
  
    @Override
    public boolean hasNext() {
        if (closed) {
            throw new IllegalStateException("迭代器已关闭");
        }
        return delegate.hasNext();
    }
  
    @Override
    public T next() {
        if (closed) {
            throw new IllegalStateException("迭代器已关闭");
        }
        return delegate.next();
    }
  
    @Override
    public void remove() {
        if (closed) {
            throw new IllegalStateException("迭代器已关闭");
        }
        delegate.remove();
    }
  
    @Override
    public void close() {
        closed = true;
        // 清理资源
        if (delegate instanceof AutoCloseable) {
            try {
                ((AutoCloseable) delegate).close();
            } catch (Exception e) {
                // 记录日志
            }
        }
    }
}

// 使用示例
public class IteratorMemoryDemo {
    public static void main(String[] args) {
        try (CloseableIterator<String> iterator = new CloseableIterator<>(
                Arrays.asList("a", "b", "c").iterator())) {
            while (iterator.hasNext()) {
                System.out.println(iterator.next());
            }
        } // 自动关闭迭代器
    }
}

重难点4：迭代器的性能优化

问题描述

如何优化迭代器的性能，减少不必要的计算。

解决方案

java 复制代码

// 缓存迭代器
public class CachedIterator<T> implements Iterator<T> {
    private final Iterator<T> delegate;
    private final Map<Integer, T> cache = new HashMap<>();
    private int currentIndex = 0;
  
    public CachedIterator(Iterator<T> delegate) {
        this.delegate = delegate;
    }
  
    @Override
    public boolean hasNext() {
        return delegate.hasNext();
    }
  
    @Override
    public T next() {
        if (cache.containsKey(currentIndex)) {
            T element = cache.get(currentIndex);
            currentIndex++;
            return element;
        }
      
        T element = delegate.next();
        cache.put(currentIndex, element);
        currentIndex++;
        return element;
    }
  
    public void reset() {
        currentIndex = 0;
    }
  
    public void clearCache() {
        cache.clear();
    }
}

// 延迟计算迭代器
public class LazyIterator<T> implements Iterator<T> {
    private final Supplier<Iterator<T>> iteratorSupplier;
    private Iterator<T> delegate;
    private boolean initialized = false;
  
    public LazyIterator(Supplier<Iterator<T>> iteratorSupplier) {
        this.iteratorSupplier = iteratorSupplier;
    }
  
    private void ensureInitialized() {
        if (!initialized) {
            this.delegate = iteratorSupplier.get();
            this.initialized = true;
        }
    }
  
    @Override
    public boolean hasNext() {
        ensureInitialized();
        return delegate.hasNext();
    }
  
    @Override
    public T next() {
        ensureInitialized();
        return delegate.next();
    }
  
    @Override
    public void remove() {
        ensureInitialized();
        delegate.remove();
    }
}

Spring中的源码分析

Spring的Iterator接口

java 复制代码

// Spring的Iterator接口
public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Spring的Iterable接口

java 复制代码

// Spring的Iterable接口
public interface Iterable<T> {
    Iterator<T> iterator();
  
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
  
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Spring的Collection接口

java 复制代码

// Spring的Collection接口
public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
    boolean equals(Object o);
    int hashCode();
}

Spring的List接口

java 复制代码

// Spring的List接口
public interface List<E> extends Collection<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean addAll(int index, Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
    boolean equals(Object o);
    int hashCode();
    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    int indexOf(Object o);
    int lastIndexOf(Object o);
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
    List<E> subList(int fromIndex, int toIndex);
}

Spring的ArrayList实现

java 复制代码

// Spring的ArrayList实现
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
  
    private static final int DEFAULT_CAPACITY = 10;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    transient Object[] elementData;
    private int size;
  
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
  
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        }
    }
  
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
  
    @Override
    public Iterator<E> iterator() {
        return new Itr();
    }
  
    private class Itr implements Iterator<E> {
        int cursor;
        int lastRet = -1;
        int expectedModCount = modCount;
      
        Itr() {}
      
        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();
            }
        }
      
        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }
      
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

具体使用场景

1. 文件系统遍历

java 复制代码

// 文件系统迭代器
public class FileSystemIterator implements Iterator<File> {
    private final Queue<File> queue = new LinkedList<>();
    private final boolean includeDirectories;
    private final boolean includeFiles;
  
    public FileSystemIterator(File root, boolean includeDirectories, boolean includeFiles) {
        this.includeDirectories = includeDirectories;
        this.includeFiles = includeFiles;
        if (root.exists()) {
            queue.offer(root);
        }
    }
  
    @Override
    public boolean hasNext() {
        while (!queue.isEmpty()) {
            File current = queue.peek();
            if (current.isDirectory()) {
                if (includeDirectories) {
                    return true;
                }
                queue.poll();
                addChildren(current);
            } else if (current.isFile()) {
                if (includeFiles) {
                    return true;
                }
                queue.poll();
            } else {
                queue.poll();
            }
        }
        return false;
    }
  
    @Override
    public File next() {
        if (!hasNext()) {
            throw new NoSuchElementException("没有更多文件");
        }
        return queue.poll();
    }
  
    private void addChildren(File directory) {
        File[] children = directory.listFiles();
        if (children != null) {
            for (File child : children) {
                queue.offer(child);
            }
        }
    }
}

// 使用示例
public class FileSystemDemo {
    public static void main(String[] args) {
        File root = new File("/path/to/directory");
        FileSystemIterator iterator = new FileSystemIterator(root, true, true);
      
        while (iterator.hasNext()) {
            File file = iterator.next();
            System.out.println("文件: " + file.getAbsolutePath());
        }
    }
}

2. 数据库结果集遍历

java 复制代码

// 数据库结果集迭代器
public class ResultSetIterator implements Iterator<Map<String, Object>> {
    private final ResultSet resultSet;
    private final ResultSetMetaData metaData;
    private boolean hasNext;
  
    public ResultSetIterator(ResultSet resultSet) throws SQLException {
        this.resultSet = resultSet;
        this.metaData = resultSet.getMetaData();
        this.hasNext = resultSet.next();
    }
  
    @Override
    public boolean hasNext() {
        return hasNext;
    }
  
    @Override
    public Map<String, Object> next() {
        if (!hasNext) {
            throw new NoSuchElementException("没有更多记录");
        }
      
        try {
            Map<String, Object> row = new HashMap<>();
            int columnCount = metaData.getColumnCount();
          
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColumnName(i);
                Object value = resultSet.getObject(i);
                row.put(columnName, value);
            }
          
            hasNext = resultSet.next();
            return row;
        } catch (SQLException e) {
            throw new RuntimeException("读取数据库记录失败", e);
        }
    }
}

// 使用示例
public class DatabaseDemo {
    public static void main(String[] args) {
        try (Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "user", "password");
             PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users");
             ResultSet rs = stmt.executeQuery()) {
          
            ResultSetIterator iterator = new ResultSetIterator(rs);
            while (iterator.hasNext()) {
                Map<String, Object> row = iterator.next();
                System.out.println("用户: " + row);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

3. 树形结构遍历

java 复制代码

// 树节点
public class TreeNode<T> {
    private T data;
    private List<TreeNode<T>> children;
  
    public TreeNode(T data) {
        this.data = data;
        this.children = new ArrayList<>();
    }
  
    public void addChild(TreeNode<T> child) {
        children.add(child);
    }
  
    public T getData() { return data; }
    public List<TreeNode<T>> getChildren() { return children; }
}

// 树形结构迭代器
public class TreeIterator<T> implements Iterator<T> {
    private final Queue<TreeNode<T>> queue = new LinkedList<>();
  
    public TreeIterator(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> current = queue.poll();
        for (TreeNode<T> child : current.getChildren()) {
            queue.offer(child);
        }
      
        return current.getData();
    }
}

// 使用示例
public class TreeDemo {
    public static void main(String[] args) {
        TreeNode<String> root = new TreeNode<>("根节点");
        TreeNode<String> child1 = new TreeNode<>("子节点1");
        TreeNode<String> child2 = new TreeNode<>("子节点2");
        TreeNode<String> grandchild1 = new TreeNode<>("孙子节点1");
        TreeNode<String> grandchild2 = new TreeNode<>("孙子节点2");
      
        root.addChild(child1);
        root.addChild(child2);
        child1.addChild(grandchild1);
        child2.addChild(grandchild2);
      
        TreeIterator<String> iterator = new TreeIterator<>(root);
        while (iterator.hasNext()) {
            String node = iterator.next();
            System.out.println("节点: " + node);
        }
    }
}

面试高频点

面试知识点思维导图

迭代器模式面试点基本概念实现方式重难点 Spring应用设计原则实际应用分离遍历逻辑统一访问接口封装内部结构支持多种遍历 Iterator抽象迭代器 ConcreteIterator具体迭代器 Aggregate抽象聚合类 ConcreteAggregate具体聚合类并发安全快照机制内存管理性能优化 Iterator接口 Iterable接口 Collection接口 ArrayList实现单一职责开闭原则依赖倒置接口隔离文件系统遍历数据库结果集遍历树形结构遍历集合遍历

1. 迭代器模式的基本概念

问题：什么是迭代器模式？

答案要点：

提供一种方法顺序访问一个聚合对象中各个元素
无须暴露该对象的内部表示
属于行为型设计模式
把在元素之间游走的责任交给迭代器

问题：迭代器模式有哪些角色？

答案要点：

Iterator（抽象迭代器）：定义访问和遍历元素的接口
ConcreteIterator（具体迭代器）：实现抽象迭代器接口，完成对聚合对象的遍历
Aggregate（抽象聚合类）：定义创建迭代器对象的接口
ConcreteAggregate（具体聚合类）：实现抽象聚合类，返回具体迭代器的实例

2. 实现方式相关

问题：如何实现迭代器模式？

答案要点：

java 复制代码

// 1. 定义抽象迭代器接口
public interface Iterator<T> {
    boolean hasNext();
    T next();
    void remove();
}

// 2. 定义抽象聚合类
public interface Aggregate<T> {
    Iterator<T> createIterator();
}

// 3. 实现具体迭代器
public class ConcreteIterator<T> implements Iterator<T> {
    private Aggregate<T> aggregate;
    private int currentIndex = 0;
  
    public ConcreteIterator(Aggregate<T> aggregate) {
        this.aggregate = aggregate;
    }
  
    @Override
    public boolean hasNext() {
        return currentIndex < aggregate.size();
    }
  
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        T element = aggregate.get(currentIndex);
        currentIndex++;
        return element;
    }
}

3. 重难点问题

问题：如何解决迭代器的并发安全问题？

答案要点：

java 复制代码

// 1. 使用同步机制
public class SynchronizedIterator<T> implements Iterator<T> {
    private final List<T> elements;
    private final Object lock = new Object();
    private int currentIndex = 0;
  
    @Override
    public boolean hasNext() {
        synchronized (lock) {
            return currentIndex < elements.size();
        }
    }
  
    @Override
    public T next() {
        synchronized (lock) {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            T element = elements.get(currentIndex);
            currentIndex++;
            return element;
        }
    }
}

// 2. 使用快照机制
public class SnapshotIterator<T> implements Iterator<T> {
    private final List<T> snapshot;
    private int currentIndex = 0;
  
    public SnapshotIterator(Collection<T> original) {
        this.snapshot = new ArrayList<>(original);
    }
  
    @Override
    public boolean hasNext() {
        return currentIndex < snapshot.size();
    }
  
    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        T element = snapshot.get(currentIndex);
        currentIndex++;
        return element;
    }
}

问题：迭代器模式与for循环的区别？

答案要点：

封装性：迭代器模式封装了遍历逻辑，for循环暴露了内部结构
统一性：迭代器模式提供统一的遍历接口，for循环需要针对不同集合编写不同代码
扩展性：迭代器模式易于扩展，for循环难以扩展
安全性：迭代器模式可以控制并发访问，for循环难以控制

4. Spring中的应用

问题：Spring中如何使用迭代器模式？

答案要点：

java 复制代码

// 1. 使用Iterator接口
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

// 2. 使用增强for循环
for (String element : list) {
    System.out.println(element);
}

// 3. 使用Stream API
list.stream().forEach(System.out::println);

5. 设计原则相关

问题：迭代器模式体现了哪些设计原则？

答案要点：

单一职责：迭代器只负责遍历，聚合对象只负责存储
开闭原则：可以添加新的迭代器类型而不修改现有代码
依赖倒置：依赖抽象而不是具体实现
接口隔离：客户端只依赖需要的接口

6. 实际应用场景

问题：迭代器模式适用于哪些场景？

答案要点：

集合遍历：List、Set、Map等集合的遍历
文件系统：文件系统目录的遍历
数据库：数据库结果集的遍历
树形结构：树形结构的遍历
复杂对象：复杂对象的属性遍历

使用总结

迭代器模式的优势

解耦：将遍历逻辑从聚合对象中分离出来
统一接口：为不同的聚合对象提供统一的遍历接口
封装内部结构：隐藏聚合对象的内部实现细节
支持多种遍历：可以同时进行多个遍历操作

迭代器模式的缺点

复杂度增加：增加了系统的复杂度
性能开销：迭代器对象会占用额外内存
学习成本：需要理解迭代器模式的概念
过度设计：简单场景可能不需要使用

使用建议

复杂遍历：只用于复杂的遍历场景
统一接口：需要为不同集合提供统一遍历接口时使用
并发安全：多线程环境下注意并发安全
性能考虑：权衡迭代器模式的性能开销

最佳实践

实现Iterable接口：让聚合对象实现Iterable接口
异常处理：正确处理NoSuchElementException
资源管理：实现AutoCloseable接口管理资源
文档注释：为迭代器方法添加详细的文档注释
单元测试：为迭代器功能编写单元测试

与其他模式的对比

与访问者模式：迭代器模式是遍历元素，访问者模式是处理元素
与命令模式：迭代器模式是遍历操作，命令模式是封装操作
与策略模式：迭代器模式是遍历策略，策略模式是算法策略

迭代器模式是一种有用的行为型设计模式，特别适用于需要遍历复杂数据结构、提供统一遍历接口、封装内部实现细节等场景。通过合理使用迭代器模式，可以大大提高代码的可维护性和可扩展性。

设计模式-迭代器模式详解

迭代器模式详解

目录

迭代器模式简介

定义

核心思想

模式结构

核心流程

迭代器模式流程图

基本实现流程

1. 定义抽象迭代器接口

2. 定义抽象聚合类

3. 实现具体迭代器

4. 实现具体聚合类

5. 客户端使用

重难点分析

重难点1：迭代器的并发安全

问题描述

解决方案

重难点2：迭代器的快照机制

问题描述

解决方案

重难点3：迭代器的内存管理

问题描述

解决方案

重难点4：迭代器的性能优化

问题描述

解决方案

Spring中的源码分析

Spring的Iterator接口

Spring的Iterable接口

Spring的Collection接口

Spring的List接口

Spring的ArrayList实现

具体使用场景

1. 文件系统遍历

2. 数据库结果集遍历

3. 树形结构遍历

面试高频点

面试知识点思维导图

1. 迭代器模式的基本概念

问题：什么是迭代器模式？

问题：迭代器模式有哪些角色？

2. 实现方式相关

问题：如何实现迭代器模式？

3. 重难点问题

问题：如何解决迭代器的并发安全问题？

问题：迭代器模式与for循环的区别？

4. Spring中的应用

问题：Spring中如何使用迭代器模式？

5. 设计原则相关

问题：迭代器模式体现了哪些设计原则？

6. 实际应用场景

问题：迭代器模式适用于哪些场景？

使用总结

迭代器模式的优势

迭代器模式的缺点

使用建议

最佳实践

与其他模式的对比