迭代器模式详解：原理、实现与应用场景

1. 为什么需要迭代器模式

在软件开发中，我们经常需要处理各种集合数据。想象你正在开发一个音乐播放器应用，里面可能有以下几种集合：

• 播放列表（线性列表）
• 歌曲分类（树形结构）
• 最近播放记录（栈结构）
• 好友分享的歌曲（图结构）

如果每次遍历这些集合时，都需要了解它们的具体实现方式，代码会变得非常混乱。比如要遍历树形结构的分类，你可能需要写递归代码；而遍历线性列表时，又需要写for循环。这就是迭代器模式要解决的问题。

关键点：迭代器模式的核心价值在于将集合的存储结构与遍历行为解耦，让客户端可以用统一的方式访问各种集合。

2. 迭代器模式的核心结构

2.1 基本组件

迭代器模式主要包含四个关键角色：

1. Iterator接口：

java复制public interface Iterator<T> {
    boolean hasNext();
    T next();
    void remove(); // 可选
}

2. ConcreteIterator实现：

java复制public class PlaylistIterator implements Iterator<Song> {
    private List<Song> songs;
    private int position = 0;
    
    public PlaylistIterator(List<Song> songs) {
        this.songs = songs;
    }
    
    @Override
    public boolean hasNext() {
        return position < songs.size();
    }
    
    @Override
    public Song next() {
        return songs.get(position++);
    }
}

3. Collection接口：

java复制public interface Playlist {
    Iterator<Song> createIterator();
    void addSong(Song song);
}

4. ConcreteCollection实现：

java复制public class DefaultPlaylist implements Playlist {
    private List<Song> songs = new ArrayList<>();
    
    @Override
    public Iterator<Song> createIterator() {
        return new PlaylistIterator(songs);
    }
    
    @Override
    public void addSong(Song song) {
        songs.add(song);
    }
}

2.2 模式关系图

code复制[Client] --> [Collection]
[Client] --> [Iterator]
[Collection] <|-- [ConcreteCollection]
[Iterator] <|-- [ConcreteIterator]
[ConcreteCollection] --> [ConcreteIterator]

3. 迭代器模式的五种典型实现方式

3.1 内部类实现

最经典的做法是在集合类内部实现迭代器：

java复制public class TreeCollection implements Collection {
    // 树结构的实现...
    
    private class TreeIterator implements Iterator {
        // 可以访问外部类的私有成员
        public boolean hasNext() { ... }
        public Object next() { ... }
    }
    
    public Iterator iterator() {
        return new TreeIterator();
    }
}

3.2 外部迭代器

迭代器作为独立类存在：

java复制public class FileSystemIterator implements Iterator {
    private File[] files;
    private int index;
    
    public FileSystemIterator(String path) {
        this.files = new File(path).listFiles();
    }
    // 实现接口方法...
}

3.3 泛型迭代器

Java风格的泛型实现：

java复制public interface Iterable<T> {
    Iterator<T> iterator();
}

public class GenericCollection<T> implements Iterable<T> {
    private T[] elements;
    // 其他实现...
}

3.4 惰性迭代器

特别适合大数据集合的遍历：

java复制public class DatabaseIterator implements Iterator {
    private ResultSet rs;
    private boolean hasNext;
    
    public DatabaseIterator(ResultSet rs) {
        this.rs = rs;
        advance();
    }
    
    private void advance() {
        try {
            hasNext = rs.next();
        } catch (SQLException e) {
            hasNext = false;
        }
    }
    // 实现接口方法...
}

3.5 过滤迭代器

实现条件过滤功能：

java复制public class FilteringIterator implements Iterator {
    private Iterator source;
    private Predicate predicate;
    private Object nextItem;
    
    public FilteringIterator(Iterator source, Predicate predicate) {
        this.source = source;
        this.predicate = predicate;
        advance();
    }
    
    private void advance() {
        while (source.hasNext()) {
            Object item = source.next();
            if (predicate.test(item)) {
                nextItem = item;
                return;
            }
        }
        nextItem = null;
    }
    // 实现接口方法...
}

4. 迭代器模式在真实项目中的应用

4.1 Java集合框架

Java的Collection框架是迭代器模式的最佳示例：

java复制List<String> list = new ArrayList<>();
list.add("A");
list.add("B");

// 使用迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// 增强for循环底层也是迭代器
for (String s : list) {
    System.out.println(s);
}

4.2 文件系统遍历

实现跨平台的文件遍历：

java复制public class FileSystem implements Iterable<File> {
    private File root;
    
    public FileSystem(String rootPath) {
        this.root = new File(rootPath);
    }
    
    @Override
    public