设计模式——迭代器模式

迭代器模式 (Iterator Pattern)

什么是迭代器模式？

迭代器模式是一种行为型设计模式，它允许你遍历集合对象中的元素，而不暴露集合的内部表示。

简单来说：迭代器模式就是提供一个统一的接口来遍历不同的集合。

生活中的例子

想象一下：

电视遥控器：上一个频道、下一个频道
音乐播放器：上一首、下一首
翻书：上一页、下一页

为什么需要迭代器模式？

传统方式的问题

java 复制代码

// 客户端需要了解集合的内部结构
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

问题：

暴露内部：暴露了集合的内部结构
不统一：不同集合的遍历方式不同
难以扩展：新增集合类型需要修改客户端

迭代器模式的优势

java 复制代码

// 使用迭代器
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

优势：

统一接口：提供统一的遍历接口
隐藏内部：隐藏集合的内部结构
易于扩展：新增集合类型很容易

迭代器模式的结构

复制代码

┌─────────────────────┐
│     Iterator        │  迭代器接口
├─────────────────────┤
│ + hasNext(): boolean│
│ + next(): Object    │
└──────────┬──────────┘
           │ 实现
           │
┌──────────┴──────────┐
│  ConcreteIterator   │  具体迭代器
├─────────────────────┤
│ - index: int        │
│ - collection: Col   │
│ + hasNext(): boolean│
│ + next(): Object    │
└─────────────────────┘

┌─────────────────────┐
│    Iterable         │  可迭代接口
├─────────────────────┤
│ + iterator(): Iter  │
└──────────┬──────────┘
           │ 实现
           │
┌──────────┴──────────┐
│  ConcreteCollection │  具体集合
├─────────────────────┤
│ - elements: List    │
│ + iterator(): Iter  │
└─────────────────────┘

代码示例

1. 定义迭代器接口

java 复制代码

/**
 * 迭代器接口
 */
public interface Iterator {
    /**
     * 是否有下一个元素
     */
    boolean hasNext();
    
    /**
     * 获取下一个元素
     */
    Object next();
}

2. 定义可迭代接口

java 复制代码

/**
 * 可迭代接口
 */
public interface Iterable {
    /**
     * 获取迭代器
     */
    Iterator iterator();
}

3. 定义具体迭代器

java 复制代码

/**
 * 具体迭代器
 */
public class ConcreteIterator implements Iterator {
    private List<Object> elements;
    private int index = 0;
    
    public ConcreteIterator(List<Object> elements) {
        this.elements = elements;
    }
    
    @Override
    public boolean hasNext() {
        return index < elements.size();
    }
    
    @Override
    public Object next() {
        if (hasNext()) {
            return elements.get(index++);
        }
        return null;
    }
}

4. 定义具体集合

java 复制代码

/**
 * 具体集合
 */
public class ConcreteCollection implements Iterable {
    private List<Object> elements = new ArrayList<>();
    
    public void add(Object element) {
        elements.add(element);
    }
    
    @Override
    public Iterator iterator() {
        return new ConcreteIterator(elements);
    }
}

5. 使用迭代器

java 复制代码

/**
 * 迭代器模式测试类
 * 演示如何使用迭代器模式遍历集合
 */
public class IteratorTest {
    
    public static void main(String[] args) {
        System.out.println("=== 迭代器模式测试 ===\n");
        
        // 创建集合
        ConcreteCollection collection = new ConcreteCollection();
        collection.add("元素1");
        collection.add("元素2");
        collection.add("元素3");
        collection.add("元素4");
        collection.add("元素5");
        
        // 使用迭代器遍历
        System.out.println("--- 使用迭代器遍历 ---");
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
        System.out.println("\n=== 迭代器模式的优势 ===");
        System.out.println("1. 统一接口：提供统一的遍历接口");
        System.out.println("2. 隐藏内部：隐藏集合的内部结构");
        System.out.println("3. 易于扩展：新增集合类型很容易");
        System.out.println("4. 简化客户端：简化客户端代码");
        
        System.out.println("\n=== 实际应用场景 ===");
        System.out.println("1. 集合框架：Java集合框架");
        System.out.println("2. 数据库查询：数据库结果集");
        System.out.println("3. 文件遍历：文件系统遍历");
        System.out.println("4. 树形结构：树形结构遍历");
        
        System.out.println("\n=== Java中的迭代器 ===");
        System.out.println("Java中的集合框架都实现了Iterable接口：");
        System.out.println("- List: ArrayList, LinkedList");
        System.out.println("- Set: HashSet, TreeSet");
        System.out.println("- Map: HashMap, TreeMap (通过entrySet())");
        System.out.println("\n使用for-each循环：");
        System.out.println("for (Object element : collection) {");
        System.out.println("    System.out.println(element);");
        System.out.println("}");
    }
}

迭代器模式的优点

统一接口：提供统一的遍历接口
隐藏内部：隐藏集合的内部结构
易于扩展：新增集合类型很容易
简化客户端：简化客户端代码

迭代器模式的缺点

增加复杂度：引入了额外的类
性能开销：多了一层调用

适用场景

遍历集合：需要遍历集合对象
统一接口：需要统一的遍历接口
隐藏内部：需要隐藏集合的内部结构

常见应用场景

集合框架：Java集合框架
数据库查询：数据库结果集
文件遍历：文件系统遍历

使用建议

遍历集合：使用迭代器模式
统一接口：使用迭代器模式
简单遍历：直接使用for循环即可

注意事项

⚠️ 迭代器模式虽然有用，但要注意：

考虑使用for-each循环
注意并发修改问题