Java设计模式之迭代器模式详解

Java设计模式之迭代器模式详解


一、迭代器模式核心思想

核心目标提供一种方法顺序访问聚合对象中的元素,而不暴露其内部实现。如同导游带领游客参观景点,游客无需知道景点的组织方式,只需跟随导游即可遍历所有景点。


二、迭代器模式类图(Mermaid)

创建 <<interface>> Aggregate +createIterator() : Iterator ConcreteAggregate -items: List +createIterator() : Iterator +size() : int +get(int) : Item <<interface>> Iterator +hasNext() : boolean +next() : Object ConcreteIterator -aggregate: ConcreteAggregate -position: int +hasNext() : boolean +next() : Object Client


三、代码实现示例

1. 自定义集合迭代器

java 复制代码
// 迭代器接口
interface Iterator<T> {
    boolean hasNext();
    T next();
    void remove();
}

// 聚合接口
interface IterableCollection<T> {
    Iterator<T> createIterator();
}

// 具体集合:书架
class BookShelf implements IterableCollection<Book> {
    private List<Book> books = new ArrayList<>();
    
    public void addBook(Book book) {
        books.add(book);
    }
    
    public Book getBook(int index) {
        return books.get(index);
    }
    
    public int size() {
        return books.size();
    }
    
    @Override
    public Iterator<Book> createIterator() {
        return new BookShelfIterator(this);
    }
}

// 具体迭代器
class BookShelfIterator implements Iterator<Book> {
    private BookShelf bookShelf;
    private int position;
    
    public BookShelfIterator(BookShelf bookShelf) {
        this.bookShelf = bookShelf;
        this.position = 0;
    }
    
    @Override
    public boolean hasNext() {
        return position < bookShelf.size();
    }
    
    @Override
    public Book next() {
        Book book = bookShelf.getBook(position);
        position++;
        return book;
    }
    
    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

// 书籍类
class Book {
    private String title;
    public Book(String title) { this.title = title; }
    public String getTitle() { return title; }
}

// 客户端调用
public class Client {
    public static void main(String[] args) {
        BookShelf shelf = new BookShelf();
        shelf.addBook(new Book("设计模式"));
        shelf.addBook(new Book("Java核心技术"));
        shelf.addBook(new Book("算法导论"));
        
        Iterator<Book> it = shelf.createIterator();
        while (it.hasNext()) {
            System.out.println(it.next().getTitle());
        }
        /* 输出:
           设计模式
           Java核心技术
           算法导论 */
    }
}

四、模式优缺点分析

✅ 优势

  • 解耦集合与遍历:客户端无需知道集合内部结构
  • 支持多种遍历方式:可定义不同迭代器(正序/逆序/过滤等)
  • 单一职责原则:集合管理数据,迭代器负责遍历
  • 并行遍历:支持多迭代器同时操作

❌ 缺点

  • 简单集合不适用:对小型集合可能过度设计
  • 性能开销:迭代器对象创建成本
  • 修改集合风险:遍历时修改集合可能导致异常

五、典型应用场景

  1. 集合框架:Java的List、Set、Map迭代器
  2. 树形结构遍历:二叉树/BFS/DFS迭代器
  3. 数据库查询:ResultSet遍历
  4. 文件系统:目录递归遍历
  5. 社交网络:好友关系遍历
  6. 游戏地图:网格单元遍历

六、Mermaid序列图(迭代过程)

Client Iterator Aggregate createIterator() Iterator hasNext() true next() get(position) Item Item loop while hasNext() hasNext() false Client Iterator Aggregate


七、迭代器模式 vs 其他模式

对比模式 核心区别
访问者模式 对集合元素执行操作,不控制遍历顺序
组合模式 处理树形结构,迭代器可遍历组合
工厂方法 用于创建迭代器对象

八、Java集合框架中的迭代器

Java迭代器层次结构

实现 <<interface>> Iterable +iterator() : Iterator <<interface>> Iterator +hasNext() +next() +remove() <<interface>> ListIterator +hasPrevious() +previous() +add() +set() ArrayList +iterator() Collection List


九、高级应用技巧

1. 过滤迭代器(只返回符合条件的元素)

java 复制代码
class FilterIterator<T> implements Iterator<T> {
    private Iterator<T> source;
    private Predicate<T> filter;
    private T nextItem;
    
    public FilterIterator(Iterator<T> source, Predicate<T> filter) {
        this.source = source;
        this.filter = filter;
        findNext();
    }
    
    private void findNext() {
        nextItem = null;
        while (source.hasNext()) {
            T item = source.next();
            if (filter.test(item)) {
                nextItem = item;
                break;
            }
        }
    }
    
    public boolean hasNext() {
        return nextItem != null;
    }
    
    public T next() {
        T result = nextItem;
        findNext();
        return result;
    }
}

// 使用示例
Iterator<Book> it = new FilterIterator<>(
    shelf.createIterator(), 
    book -> book.getTitle().contains("Java")
);

2. 并发安全迭代器

java 复制代码
class ConcurrentIterator<T> implements Iterator<T> {
    private final List<T> snapshot;
    private int position;
    
    public ConcurrentIterator(Collection<T> collection) {
        this.snapshot = new ArrayList<>(collection);  // 创建快照
    }
    
    public boolean hasNext() {
        return position < snapshot.size();
    }
    
    public T next() {
        return snapshot.get(position++);
    }
}

十、实际框架应用案例

Spring Data的Repository迭代

java 复制代码
Iterable<User> users = userRepository.findAll();
Iterator<User> it = users.iterator();
while (it.hasNext()) {
    User user = it.next();
    // 处理用户
}

Java Stream API(内部使用迭代器)

java 复制代码
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
     .filter(name -> name.length() > 4)
     .forEach(System.out::println);

十一、常见问题解答

Q1:如何在遍历时安全删除元素?

使用迭代器的remove()方法:

java 复制代码
Iterator<Book> it = shelf.createIterator();
while (it.hasNext()) {
    Book book = it.next();
    if (book.getTitle().contains("过期")) {
        it.remove();  // 安全删除
    }
}

Q2:如何实现双向遍历?

使用ListIterator

java 复制代码
ListIterator<Book> it = books.listIterator();
it.next();           // 正向遍历
it.previous();       // 返回上一个
it.add(newBook);     // 添加元素

Q3:迭代器模式如何支持并行遍历?

java 复制代码
// 创建多个独立迭代器
Iterator<Book> it1 = shelf.createIterator();
Iterator<Book> it2 = shelf.createIterator();

// 线程1使用it1遍历
// 线程2使用it2遍历

如果你觉得文章对你有帮助的话,帮忙点个关注吧!谢谢啦

相关推荐
都叫我大帅哥6 小时前
Java JJWT 完全指南:从入门到生产级实践
java
前端开发张小七7 小时前
Java 学习笔记 · 第一课:基础语法与核心概念
java·后端
ThsPool8 小时前
【ENVI二次开发学习整理 04】ENVI功能扩展与二次开发
java·前端·javascript
赤壁小虾8 小时前
【渲染流水线】[逐片元阶段]-[透明度测试]以UnityURP为例
java·前端·数据库
青山木9 小时前
Hot 100 --- 搜索插入位置
java·数据结构·算法·leetcode
Jul1en_9 小时前
【Claude Code Compact】源码级别的学习上下文压缩
java·前端·学习·github·ai编程
摇滚侠9 小时前
《SpringBoot 3:入门与应用实战》第 15 章 生产级特性 管理 Spring Boot 应用 阅读笔记
java·spring boot·笔记
XWalnut10 小时前
SpringBoot快速入门
java·spring boot·后端
前端 贾公子10 小时前
第06章:结构化输出 (上)
java·服务器·前端
念何架构之路10 小时前
restartmanager-重启管理子系统
java·开发语言