郑开源的遍历之旅-迭代器模式-优快云博客

引言：一个程序员的烦恼

在一个阳光明媚的周一早晨，程序员郑开源坐在工位上，面对着一堆需要处理的数据结构，陷入了深深的思考。他的桌上放着一杯还冒着热气的咖啡，屏幕上显示着各种集合类：ArrayList、LinkedList、HashMap、TreeSet…

"每次遍历不同的数据结构，都要写不同的代码，这太麻烦了！"郑开源揉了揉太阳穴，“ArrayList用索引，LinkedList用节点，HashMap用entrySet()，每种都不一样，能不能有一种统一的方式来遍历所有的集合呢？”

正当他苦恼时，技术总监老王走了过来…

📚 第一章：发现问题的根源

1.1 郑开源的困境

郑开源正在开发一个用户管理系统，需要处理不同类型的用户数据：

// 普通用户列表 - 使用ArrayList
List<User> normalUsers = new ArrayList<>();
normalUsers.add(new User("张三", "normal"));
normalUsers.add(new User("李四", "normal"));

// VIP用户列表 - 使用LinkedList
LinkedList<User> vipUsers = new LinkedList<>();
vipUsers.add(new User("王五", "vip"));
vipUsers.add(new User("赵六", "vip"));

// 管理员映射 - 使用HashMap
Map<String, User> adminUsers = new HashMap<>();
adminUsers.put("admin1", new User("管理员1", "admin"));
adminUsers.put("admin2", new User("管理员2", "admin"));

每次要遍历这些数据，郑开源都要写不同的代码：

// 遍历ArrayList - 使用传统for循环
System.out.println("=== 普通用户 ===");
for (int i = 0; i < normalUsers.size(); i++) {
   
   
    User user = normalUsers.get(i);
    System.out.println("用户: " + user.getName() + ", 类型: " + user.getType());
}

// 遍历LinkedList - 使用增强for循环
System.out.println("=== VIP用户 ===");
for (User user : vipUsers) {
   
   
    System.out.println("用户: " + user.getName() + ", 类型: " + user.getType());
}

// 遍历HashMap - 使用entrySet
System.out.println("=== 管理员用户 ===");
for (Map.Entry<String, User> entry : adminUsers.entrySet()) {
   
   
    User user = entry.getValue();
    System.out.println("用户: " + user.getName() + ", 类型: " + user.getType());
}

"这样写代码太繁琐了！"郑开源抱怨道，“每种数据结构都要记住不同的遍历方式，而且代码重复度很高。”

1.2 老王的启发

技术总监老王看了看郑开源的代码，微笑着说：“开源啊，你有没有想过，为什么我们可以用增强for循环来遍历不同的集合？”

"嗯？"郑开源愣了一下，“因为…因为Java语法支持？”

"不对，"老王摇摇头，“是因为这些集合都实现了同一个接口，这就是迭代器模式的体现。”

老王在白板上画了一个图：

Collection接口
    ↓
实现Iterable接口
    ↓
提供iterator()方法
    ↓
返回Iterator对象
    ↓
统一的遍历方式

"看到了吗？"老王指着图说，“ArrayList、LinkedList、HashSet等等，它们都实现了Iterable接口，所以都可以用相同的方式遍历。这就是迭代器模式的魅力！”

📖 第二章：理解迭代器模式

2.1 什么是迭代器模式

郑开源恍然大悟：“原来如此！迭代器模式就是提供一种统一的方式来遍历不同的数据结构，而不需要暴露数据结构的内部实现。”

老王点点头："没错！迭代器模式的核心思想是：

封装遍历逻辑：将遍历的具体实现封装在迭代器中
统一接口：不同的数据结构提供相同的遍历接口
隐藏内部结构：客户端不需要知道数据结构的内部实现"

2.2 迭代器模式的结构

老王继续在白板上画图：

// 迭代器接口
interface Iterator<T> {
   
   
    boolean hasNext();  // 是否还有下一个元素
    T next();          // 获取下一个元素
    void remove();     // 删除当前元素（可选）
}

// 可迭代接口
interface Iterable<T> {
   
   
    Iterator<T> iterator();  // 返回迭代器
}

// 具体的数据结构
class ConcreteCollection<T> implements Iterable<T> {
   
   
    private T[] items;
    private int size;
  
    @Override
    public Iterator<T> iterator() {
   
   
        return new ConcreteIterator();
    }
  
    // 具体迭代器实现
    private class ConcreteIterator implements Iterator<T> {
   
   
        private int position = 0;
      
        @Override
        public boolean hasNext() {
   
   
            return position < size;
        }
      
        @Override
        public T next() {
   
   
            if (!hasNext()) {
   
   
                throw new NoSuchElementException();
            }
            return items[position++];
        }
      
        @Override
        public void remove() {
   
   
            // 删除逻辑
        }
    }
}

2.3 郑开源的第一次实践

郑开源决定自己实现一个简单的迭代器来加深理解：

/**
 * 郑开源的书籍收藏管理系统
 */
public class BookCollection implements Iterable<Book> {
   
   
    private Book[] books;
    private int size;
    private int capacity;
  
    public BookCollection(int capacity) {
   
   
        this.capacity = capacity;
        this.books = new Book[capacity];
        this.size = 0;
    }
  
    public void addBook(Book book) {
   
   
        if (size < capacity) {
   
   
            books[size++] = book;
        }
    }
  
    @Override
    public Iterator<Book> iterator() {
   
   
        return new BookIterator();
    }
  
    // 内部迭代器实现
    private class BookIterator implements Iterator<Book> {
   
   
        private int currentIndex = 0;
      
        @Override
        public boolean hasNext() {
   
   
            return currentIndex < size;
        }
      
        @Override
        public Book next() {
   
   
            if (!hasNext()) {
   
   
                throw new NoSuchElementException("没有更多书籍了");
            }
            return books[currentIndex++];
        }
      
        @Override
        public void remove() {
   
   
            if (currentIndex <= 0) {
   
   
                throw new IllegalStateException("还没有调用next()方法");
            }
          
            // 删除当前元素，后面的元素前移
            for (int i = currentIndex - 1; i < size - 1; i++) {
   
   
                books[i] = books[i + 1];
            }
            size--;
            currentIndex--;
        }
    }
}

// 书籍实体类
class Book {
   
   
    private String title;
    private String author;
    private String isbn;
  
    public Book(String title, String author, String isbn) {
   
   
        this.title = title;
        this.author = author;
        this.isbn = isbn;
    }
  
    // getters and toString...
    @Override
    public String toString() {
   
   
        return String.format("《%s》- %s (ISBN: %s)", title, author, isbn);
    }
}

测试代码：

public class IteratorPatternDemo {
   
   
    public static void main(String[] args) {
   
   
        System.out.println("=== 郑开源的书籍收藏管理系统 ===");
      
        BookCollection myBooks = new BookCollection(10);
        myBooks.addBook(new Book("设计模式", "GoF", "978-0201633610"));
        myBooks.addBook(new Book("Java编程思想", "Bruce Eckel", "978-0131872486"));
        myBooks.addBook(new Book("Spring实战", "Craig Walls", "978-1617294945"));
        myBooks.addBook(new Book("深入理解Java虚拟机", "周志明", "978-7111421900"));
      
        System.out.println("📚 我的书籍收藏：");
      
        // 使用迭代器遍历 - 方式1：手动使用迭代器
        Iterator<Book> iterator = myBooks.iterator();
        while (iterator.hasNext()) {
   
   
            Book book = iterator.next();
            System.out.println("  " + book);
        }
      
        System.out.println("\n📚 使用增强for循环遍历：");
        // 使用迭代器遍历 - 方式2：增强for循环（语法糖）
        for (Book book : myBooks) {
   
   
            System.out.println("  " + book);
        }
      
        System.out.println("\n🗑️ 删除《Java编程思想》后的收藏：");
        Iterator<Book> removeIterator = myBooks.iterator();
        while (removeIterator.hasNext()) {
   
   
            Book book = removeIterator.next();
            if (book.toString().contains("Java编程思想")) {
   
   
                removeIterator.remove();
            }
        }
      
        for (Book book : myBooks) {
   
   
            System.out.println("  " + book);
        }
    }
}

运行结果：

=== 郑开源的书籍收藏管理系统 ===
📚 我的书籍收藏：
  《设计模式》- GoF (ISBN: 978-0201633610)
  《Java编程思想》- Bruce Eckel (ISBN: 978-0131872486)
  《Spring实战》- Craig Walls (ISBN: 978-1617294945)
  《深入理解Java虚拟机》- 周志明 (ISBN: 978-7111421900)

📚 使用增强for循环遍历：
  《设计模式》- GoF (ISBN: 978-0201633610)
  《Java编程思想》- Bruce Eckel (ISBN: 978-0131872486)
  《Spring实战》- Craig Walls (ISBN: 978-1617294945)
  《深入理解Java虚拟机》- 周志明 (ISBN: 978-7111421900)

🗑️ 删除《Java编程思想》后的收藏：
  《设计模式》- GoF (ISBN: 978-0201633610)
  《Spring实战》- Craig Walls (ISBN: 978-1617294945)
  《深入理解Java虚拟机》- 周志明 (ISBN: 978-7111421900)

郑开源兴奋地说：“太棒了！现在我明白了，迭代器模式让我们可以用统一的方式遍历不同的数据结构，而且还支持安全的删除操作！”

🚀 第三章：Java中的迭代器模式

3.1 Java集合框架中的迭代器

老王继续讲解：“Java集合框架是迭代器模式的经典应用。让我们看看它是如何实现的。”

/**
 * 郑开源探索Java集合框架中的迭代器
 */
public class JavaIteratorDemo {
   
   
    public static void main(String[] args) {
   
   
        System.out.println("=== Java集合框架中的迭代器模式 ===");
      
        // 1. ArrayList的迭代器
        List<String> arrayList = new ArrayList<>();
        arrayList.add("苹果");
        arrayList.add("香蕉");
        arrayList.add("橙子");
      
        System.out.println("📱 ArrayList遍历：");
        Iterator<String> listIterator = arrayList.iterator();
        while (listIterator.hasNext()) {
   
   
            System.out.println("  " + listIterator.next());
        }
      
        // 2. LinkedList的迭代器
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("第一章");
        linkedList.add("第二章");
        linkedList.add("第三章");