迭代器模式解析：解耦集合遍历与业务逻辑

1. 迭代器模式的核心价值

在软件开发中，我们经常需要处理各种集合对象（如数组、列表、树等）的遍历问题。传统做法是直接在业务代码中暴露集合的内部结构，但这会导致几个严重问题：

1. 耦合度高：业务逻辑与集合实现紧密绑定
2. 难以扩展：新增遍历方式需要修改集合类
3. 职责混乱：集合类既要管理元素又要负责遍历

迭代器模式通过将遍历行为抽象为独立对象，完美解决了这些问题。我在实际项目中见过太多因为不当遍历导致的代码维护噩梦，而合理使用迭代器模式可以让代码的可维护性提升一个数量级。

2. 模式结构与实现原理

2.1 标准UML类图解析

典型的迭代器模式包含以下核心角色：

code复制[集合接口] <<interface>>
    +createIterator()
    
[具体集合] implements 集合接口
    +createIterator()
    
[迭代器接口] <<interface>>
    +hasNext()
    +next()
    
[具体迭代器] implements 迭代器接口
    -currentPosition
    +hasNext()
    +next()

2.2 Java实现示例

java复制// 集合接口
interface Aggregate {
    Iterator createIterator();
}

// 具体集合
class ConcreteAggregate implements Aggregate {
    private String[] items = {"A", "B", "C"};
    
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
    
    public int size() {
        return items.length;
    }
    
    public String get(int index) {
        return items[index];
    }
}

// 迭代器接口
interface Iterator {
    boolean hasNext();
    Object next();
}

// 具体迭代器
class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int position = 0;
    
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }
    
    @Override
    public boolean hasNext() {
        return position < aggregate.size();
    }
    
    @Override
    public Object next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return aggregate.get(position++);
    }
}

关键点：迭代器对象持有对集合的引用，但对外只暴露遍历接口。这种设计使得我们可以：

1. 同时进行多个遍历
2. 实现不同的遍历策略
3. 不暴露集合内部结构

3. 实战应用场景

3.1 树形结构遍历

在处理组织结构、菜单系统等树形数据时，迭代器模式特别有用。我们可以实现：

• 深度优先迭代器
• 广度优先迭代器
• 层级遍历迭代器

每种迭代器实现相同的接口，客户端可以自由切换遍历方式而不需要修改业务代码。

3.2 数据库结果集处理

JDBC中的ResultSet本质上就是一个迭代器实现。这种设计使得：

• 可以分批获取数据（节省内存）
• 隐藏了底层数据库访问细节
• 支持多种游标类型

3.3 集合框架中的应用

Java集合框架是迭代器模式的经典实现：

java复制List<String> list = Arrays.asList("a", "b", "c");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

这种设计使得所有集合类型提供统一的遍历接口，极大提升了API的易用性。

4. 高级应用技巧

4.1 线程安全迭代器

在多线程环境下，我们需要考虑迭代器的线程安全问题。常见解决方案：

1. 快照迭代器：遍历集合的拷贝
2. 失败快速迭代器：检测到并发修改立即抛出异常
3. 同步迭代器：通过锁机制保证线程安全

4.2 惰性求值迭代器

对于大型数据集，可以实现惰性求值的迭代器：

java复制class LazyIterator implements Iterator {
    private DataSource source;
    private Object current;
    
    public boolean hasNext() {
        if (current == null) {
            current = source.fetchNext();
        }
        return current != null;
    }
    
    public Object next() {
        if (!hasNext()) throw new NoSuchElementException();
        Object result = current;
        current = null;
        return result;
    }
}

这种实现可以显著降低内存消耗。

4.3 组合迭代器

当需要遍历多个集合时，可以创建组合迭代器：

java复制class CompositeIterator implements Iterator {
    private Iterator[] iterators;
    private int current = 0;
    
    public boolean hasNext() {
        while (current < iterators.length) {
            if (iterators[current].hasNext()) {
                return true;
            }
            current++;
        }
        return false;
    }
    
    public Object next() {
        if (!hasNext()) throw new NoSuchElementException();
        return iterators[current].next();
    }
}

5. 模式对比与选型

5.1 迭代器 vs for循环

5.2 迭代器 vs 访问者模式

虽然两者都用于处理集合元素，但有本质区别：

• 迭代器：关注遍历过程
• 访问者：关注元素操作

在实际项目中，经常组合使用这两种模式。

6. 最佳实践与陷阱规避

6.1 使用建议

1. 优先使用语言内置的迭代器接口（如Java的Iterator）
2. 考虑实现Iterable接口使集合支持for-each语法
3. 为复杂集合提供多种迭代器实现

6.2 常见错误

1. 在迭代过程中修改集合（导致未定义行为）

   • 解决方案：使用并发集合或迭代器内部维护修改计数

2. 忽略资源释放（如数据库游标未关闭）

   • 解决方案：实现AutoCloseable接口

3. 过度设计简单场景

   • 对于数组等简单集合，直接使用for循环可能更合适

7. 现代语言中的演进

随着语言发展，迭代器模式有了新的表现形式：

7.1 内部迭代器

Java 8的Stream API就是典型的内部迭代器：

java复制list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .forEach(System.out::println);

这种声明式风格更符合现代编程趋势。

7.2 生成器函数

Python、C#等语言通过yield关键字简化迭代器实现：

python复制def count_down(n):
    while n > 0:
        yield n
        n -= 1

for i in count_down(5):
    print(i)  # 输出5,4,3,2,1

这种实现方式更加简洁直观。

8. 性能优化策略

8.1 对象池技术

对于频繁创建的迭代器对象，可以使用对象池减少GC压力：

java复制class IteratorPool {
    private static final Map<Class<?>, Queue<Iterator>> pool = new HashMap<>();
    
    public static <T> Iterator<T> borrow(Collection<T> collection) {
        Queue<Iterator> queue = pool.computeIfAbsent(
            collection.getClass(), k -> new LinkedList<>());
        
        Iterator<T> it = queue.poll();
        if (it == null) {
            it = collection.iterator();
        }
        return it;
    }
    
    public static void release(Iterator<?> it) {
        // 重置迭代器状态
        Queue<Iterator> queue = pool.get(it.getClass());
        if (queue != null) {
            queue.offer(it);
        }
    }
}

8.2 延迟初始化

对于大型集合，可以实现按需加载的迭代器：

java复制class LazyLoadingIterator implements Iterator {
    private int batchSize = 100;
    private int currentBatch = 0;
    private List<Data> currentItems;
    
    public boolean hasNext() {
        if (currentItems == null || currentBatch * batchSize >= currentItems.size()) {
            loadNextBatch();
        }
        return !currentItems.isEmpty();
    }
    
    private void loadNextBatch() {
        currentItems = dao.fetchBatch(currentBatch++, batchSize);
    }
}

9. 测试策略

9.1 单元测试要点

1. 测试空集合的遍历
2. 测试并发修改场景
3. 验证迭代顺序是否符合预期
4. 测试边界条件（如最后一个元素）

9.2 模拟测试示例

java复制@Test
void testIterator() {
    List<String> mockList = Arrays.asList("a", "b", "c");
    Iterator<String> it = mockList.iterator();
    
    assertTrue(it.hasNext());
    assertEquals("a", it.next());
    
    assertTrue(it.hasNext());
    assertEquals("b", it.next());
    
    assertTrue(it.hasNext());
    assertEquals("c", it.next());
    
    assertFalse(it.hasNext());
    assertThrows(NoSuchElementException.class, () -> it.next());
}

10. 与其他模式的协作

迭代器模式常与其他模式配合使用：

1. 组合模式：为递归结构提供统一的遍历接口
2. 工厂方法模式：由集合类决定创建何种迭代器
3. 备忘录模式：实现可回滚的迭代器状态

在实际架构设计中，这些模式的组合可以产生强大的协同效应。