行为型-迭代器模式

JavaBoy_XJ2025-12-31 11:49

1. 项目结构

bash 复制代码 
	iterator-pattern-demo/
	├── pom.xml
	├── src/
	│   ├── main/
	│   │   ├── java/
	│   │   │   └── com/
	│   │   │       └── example/
	│   │   │           └── iterator/
	│   │   │               ├── Main.java
	│   │   │               ├── aggregate/
	│   │   │               │   ├── BookCollection.java
	│   │   │               │   └── Library.java
	│   │   │               ├── iterator/
	│   │   │               │   ├── BookIterator.java
	│   │   │               │   └── LibraryIterator.java
	│   │   │               └── model/
	│   │   │                   └── Book.java
	│   │   └── resources/
	└── test/

Maven配置文件 (pom.xml)

xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>iterator-pattern-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Iterator Pattern Demo</name>
    <description>Demo project for Iterator Design Pattern</description>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 可以添加测试依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 代码实现

  1. 创建实体类 Book.java

    java 复制代码 
    package com.example.iterator.model;

/**
 * 书籍实体类
 */
public class Book {
    private String title;
    private String author;
    private String isbn;
    private int year;
    
    public Book(String title, String author, String isbn, int year) {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
        this.year = year;
    }
    
    public String getTitle() {
        return title;
    }
    
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getAuthor() {
        return author;
    }
    
    public void setAuthor(String author) {
        this.author = author;
    }
    
    public String getIsbn() {
        return isbn;
    }
    
    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }
    
    public int getYear() {
        return year;
    }
    
    public void setYear(int year) {
        this.year = year;
    }
    
    @Override
    public String toString() {
        return String.format("Book{title='%s', author='%s', isbn='%s', year=%d}", 
                title, author, isbn, year);
    }
}

  2. 通用迭代器接口

    java 复制代码 
    package com.example.iterator.iterator;

import java.util.Iterator;

/**
 * 自定义迭代器接口 - 通常我们直接使用Java内置的Iterator接口
 * 这里为了演示，我们创建自己的接口，同时展示两种方式
 */
public interface BookIterator<T> extends Iterator<T> {
    // 可以添加自定义方法
    boolean hasNext();
    T next();
}

  3. 具体迭代器实现

    java 复制代码 
    package com.example.iterator.iterator;

import com.example.iterator.model.Book;
import java.util.List;

/**
 * 书籍集合迭代器
 */
public class LibraryIterator implements BookIterator<Book> {
    private List<Book> books;
    private int position = 0;
    
    public LibraryIterator(List<Book> books) {
        this.books = books;
    }
    
    @Override
    public boolean hasNext() {
        return position < books.size() && books.get(position) != null;
    }
    
    @Override
    public Book next() {
        if (!hasNext()) {
            return null;
        }
        Book book = books.get(position);
        position++;
        return book;
    }
    
    @Override
    public void remove() {
        if (position <= 0) {
            throw new IllegalStateException("必须先调用next()才能调用remove()");
        }
        if (books.get(position - 1) != null) {
            books.remove(position - 1);
            position--;
        }
    }
}

  4. 聚合接口

    java 复制代码 
    package com.example.iterator.aggregate;

import com.example.iterator.iterator.BookIterator;
import com.example.iterator.model.Book;

/**
 * 聚合接口 - 定义创建迭代器的方法
 */
public interface BookCollection {
    BookIterator<Book> createIterator();
    void addBook(Book book);
    void removeBook(Book book);
    int size();
}

  5. 具体聚合实现

    java 复制代码 
    package com.example.iterator.aggregate;

import com.example.iterator.iterator.BookIterator;
import com.example.iterator.iterator.LibraryIterator;
import com.example.iterator.model.Book;
import java.util.ArrayList;
import java.util.List;

/**
 * 具体聚合类 - 图书馆
 */
public class Library implements BookCollection {
    private List<Book> books;
    private String name;
    
    public Library(String name) {
        this.name = name;
        this.books = new ArrayList<>();
    }
    
    public Library(String name, List<Book> initialBooks) {
        this.name = name;
        this.books = new ArrayList<>(initialBooks);
    }
    
    @Override
    public BookIterator<Book> createIterator() {
        return new LibraryIterator(books);
    }
    
    @Override
    public void addBook(Book book) {
        books.add(book);
    }
    
    @Override
    public void removeBook(Book book) {
        books.remove(book);
    }
    
    @Override
    public int size() {
        return books.size();
    }
    
    public String getName() {
        return name;
    }
    
    // 使用Java内置的Iterable接口实现迭代 - 另一种方式
    public Iterable<Book> getIterable() {
        return books; // ArrayList本身实现了Iterable接口
    }
    
    // 使用Java 8的Stream API进行迭代 - 现代方式
    public void printAllBooksUsingStream() {
        books.stream()
             .forEach(book -> System.out.println("Stream: " + book));
    }
}

  6. 另一种聚合实现

    java 复制代码 
    package com.example.iterator.aggregate;

import com.example.iterator.iterator.BookIterator;
import com.example.iterator.model.Book;
import java.util.Arrays;
import java.util.Iterator;

/**
 * 使用数组实现的聚合类
 */
public class ArrayBookCollection implements BookCollection, Iterable<Book> {
    private Book[] books;
    private int count = 0;
    
    public ArrayBookCollection(int capacity) {
        this.books = new Book[capacity];
    }
    
    @Override
    public BookIterator<Book> createIterator() {
        return new BookIterator<Book>() {
            private int index = 0;
            
            @Override
            public boolean hasNext() {
                return index < count;
            }
            
            @Override
            public Book next() {
                if (hasNext()) {
                    return books[index++];
                }
                return null;
            }
        };
    }
    
    @Override
    public void addBook(Book book) {
        if (count < books.length) {
            books[count] = book;
            count++;
        } else {
            throw new IllegalStateException("集合已满");
        }
    }
    
    @Override
    public void removeBook(Book book) {
        for (int i = 0; i < count; i++) {
            if (books[i].equals(book)) {
                // 移动元素
                for (int j = i; j < count - 1; j++) {
                    books[j] = books[j + 1];
                }
                books[count - 1] = null;
                count--;
                break;
            }
        }
    }
    
    @Override
    public int size() {
        return count;
    }
    
    // 实现Iterable接口，支持foreach循环
    @Override
    public Iterator<Book> iterator() {
        return new Iterator<Book>() {
            private int index = 0;
            
            @Override
            public boolean hasNext() {
                return index < count;
            }
            
            @Override
            public Book next() {
                if (hasNext()) {
                    return books[index++];
                }
                throw new java.util.NoSuchElementException();
            }
            
            @Override
            public void remove() {
                throw new UnsupportedOperationException("remove");
            }
        };
    }
    
    // 使用Java 8的Arrays.stream()方法
    public void printAllBooksUsingArraysStream() {
        Arrays.stream(books, 0, count)
              .forEach(book -> System.out.println("Array Stream: " + book));
    }
}

  7. 主程序 Main.java

    java 复制代码 
    package com.example.iterator;

import com.example.iterator.aggregate.ArrayBookCollection;
import com.example.iterator.aggregate.BookCollection;
import com.example.iterator.aggregate.Library;
import com.example.iterator.iterator.BookIterator;
import com.example.iterator.model.Book;

/**
 * 迭代器模式演示主类
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("========== 迭代器模式演示 ==========\n");
        
        // 1. 创建图书馆实例
        Library library = new Library("市图书馆");
        
        // 2. 添加一些书籍
        library.addBook(new Book("设计模式：可复用面向对象软件的基础", 
                "Erich Gamma等", "978-7-111-07575-4", 2000));
        library.addBook(new Book("Java编程思想", 
                "Bruce Eckel", "978-7-111-21382-6", 2007));
        library.addBook(new Book("Effective Java", 
                "Joshua Bloch", "978-7-111-58978-9", 2018));
        library.addBook(new Book("深入理解Java虚拟机", 
                "周志明", "978-7-111-54783-4", 2018));
        
        System.out.println("=== 使用自定义迭代器遍历图书馆 ===");
        BookIterator<Book> iterator = library.createIterator();
        while (iterator.hasNext()) {
            Book book = iterator.next();
            System.out.println(book);
        }
        
        System.out.println("\n=== 使用Java内置的Iterable接口（foreach） ===");
        for (Book book : library.getIterable()) {
            System.out.println("Foreach: " + book.getTitle());
        }
        
        System.out.println("\n=== 使用Java 8 Stream API ===");
        library.printAllBooksUsingStream();
        
        System.out.println("\n=== 测试数组实现的集合 ===");
        ArrayBookCollection arrayCollection = new ArrayBookCollection(5);
        arrayCollection.addBook(new Book("测试书籍1", "作者1", "ISBN-001", 2020));
        arrayCollection.addBook(new Book("测试书籍2", "作者2", "ISBN-002", 2021));
        arrayCollection.addBook(new Book("测试书籍3", "作者3", "ISBN-003", 2022));
        
        System.out.println("使用自定义迭代器:");
        BookIterator<Book> arrayIterator = arrayCollection.createIterator();
        while (arrayIterator.hasNext()) {
            System.out.println(arrayIterator.next());
        }
        
        System.out.println("\n使用Java foreach语法:");
        for (Book book : arrayCollection) {
            System.out.println("Array foreach: " + book.getTitle());
        }
        
        System.out.println("\n使用Java 8 Arrays.stream():");
        arrayCollection.printAllBooksUsingArraysStream();
        
        // 3. 演示迭代器的删除功能
        System.out.println("\n=== 演示迭代器的remove方法 ===");
        Library library2 = new Library("测试图书馆");
        library2.addBook(new Book("待删除的书", "匿名作者", "ISBN-DEL", 2020));
        library2.addBook(new Book("保留的书", "知名作者", "ISBN-KEEP", 2021));
        
        System.out.println("删除前书籍数量: " + library2.size());
        BookIterator<Book> deleteIterator = library2.createIterator();
        while (deleteIterator.hasNext()) {
            Book book = deleteIterator.next();
            if ("待删除的书".equals(book.getTitle())) {
                deleteIterator.remove();
                System.out.println("已删除: " + book.getTitle());
            }
        }
        System.out.println("删除后书籍数量: " + library2.size());
        
        System.out.println("\n========== 演示结束 ==========");
    }
    
    /**
     * 通用方法：使用迭代器遍历任何书籍集合
     */
    public static void iterateBooks(BookCollection collection) {
        System.out.println("\n通用遍历方法:");
        BookIterator<Book> iterator = collection.createIterator();
        while (iterator.hasNext()) {
            Book book = iterator.next();
            System.out.println("遍历: " + book.getTitle());
        }
    }
}

  8. 测试类

    java 复制代码 
    package com.example.iterator;

import com.example.iterator.aggregate.Library;
import com.example.iterator.model.Book;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 * 迭代器模式测试类
 */
public class IteratorPatternTest {
    
    @Test
    public void testLibraryIterator() {
        Library library = new Library("测试图书馆");
        library.addBook(new Book("测试书籍", "测试作者", "ISBN-001", 2023));
        
        assertEquals(1, library.size());
        
        int count = 0;
        var iterator = library.createIterator();
        while (iterator.hasNext()) {
            iterator.next();
            count++;
        }
        
        assertEquals(1, count);
    }
    
    @Test
    public void testRemoveBookViaIterator() {
        Library library = new Library("测试图书馆");
        Book bookToRemove = new Book("待删除", "作者", "ISBN-DEL", 2023);
        Book bookToKeep = new Book("保留", "作者", "ISBN-KEEP", 2023);
        
        library.addBook(bookToRemove);
        library.addBook(bookToKeep);
        
        assertEquals(2, library.size());
        
        var iterator = library.createIterator();
        while (iterator.hasNext()) {
            Book book = iterator.next();
            if ("待删除".equals(book.getTitle())) {
                iterator.remove();
            }
        }
        
        assertEquals(1, library.size());
    }
}

3. 构建和运行

  1. 使用Maven编译:

    bash 复制代码 
    mvn clean compile

  2. 运行主程序:

    bash 复制代码 
    mvn exec:java -Dexec.mainClass="com.example.iterator.Main"

    或者：

    bash 复制代码 
    java -cp target/classes com.example.iterator.Main

  3. 运行测试:

    bash 复制代码 
    mvn test

  4. 打包项目:

    bash 复制代码 
    mvn package

4. 核心概念

  • 分离了集合对象的遍历行为：将遍历逻辑从集合对象中分离出来，放到迭代器对象中。
  • 支持多种遍历方式：可以为同一个集合提供多种不同的遍历方式。
  • 简化了集合接口：集合本身不需要暴露内部结构。
  • 支持并行遍历：多个迭代器可以同时遍历同一个集合。
  • 与Java集合框架的集成：Java的Collection框架广泛使用了迭代器模式。
相关推荐
__万波__6 小时前
二十三种设计模式(十六)--迭代器模式
java·设计模式·迭代器模式
Yeniden11 天前
Deepeek用大白话讲解 --＞ 迭代器模式（企业级场景1，多种遍历方式2，隐藏集合结构3，Java集合框架4）
java·开发语言·迭代器模式
老朱佩琪！13 天前
Unity迭代器模式
unity·设计模式·迭代器模式
5634710018 天前
信用风险传播机制 金融网络传播模型 感染率 初始感染比例 matlab编写代码程序 复杂网络
迭代器模式
开心香辣派小星24 天前
23种设计模式-14迭代器模式
设计模式·迭代器模式
ZHE|张恒1 个月前
设计模式（十六）迭代器模式 — 统一访问集合元素的方式，不暴露内部结构
设计模式·迭代器模式
czy87874752 个月前
C语言实现迭代器模式
c语言·迭代器模式
紫荆鱼2 个月前
设计模式-迭代器模式（Iterator）
c++·后端·设计模式·迭代器模式
Meteors.2 个月前
23种设计模式——迭代器模式 (Iterator Pattern）详解
java·设计模式·迭代器模式
热门推荐
01GitHub 镜像站点02从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击03Linux下V2Ray安装配置指南04Claude Code Skills 实用使用手册05jdk21下载、安装（Windows、Linux、macOS）06UV安装并设置国内源07电脑检测软件—图吧工具箱082025 最新教程：注册并切换到美区 Apple ID09【踩坑笔记】50系显卡适配的 PyTorch 安装10Google Antigravity Agent 编辑器操作教程