Java集合遍历方法全解析与性能优化指南

1. Java遍历方法全景解析

在Java开发中，遍历集合是最基础却最频繁的操作之一。不同的遍历方式各有特点，就像工具箱里的不同工具，用对了事半功倍，用错了可能引发性能问题甚至bug。作为从业十年的Java开发者，我整理了六种主流遍历方式的实现原理、适用场景和避坑指南。

1.1 基础遍历三剑客

普通for循环是最原始的遍历方式，相当于拿着清单按编号取货：

java复制for (int i = 0; i < list.size(); i++) {
    Item item = list.get(i);
}

注意：ArrayList的get(i)是O(1)操作，但LinkedList的get(i)是O(n)操作。我曾在一个百万级LinkedList上使用普通for循环，导致接口响应从200ms暴增到15秒。

增强for循环（for-each）是语法糖，编译后实际转换为Iterator实现：

java复制for (Item item : collection) {
    // 处理item
}

底层原理是通过调用集合的iterator()方法获取迭代器。在JDK5引入后，已成为最常用的遍历方式。

Iterator迭代器提供了安全的遍历-删除操作：

java复制Iterator<Item> it = collection.iterator();
while (it.hasNext()) {
    Item item = it.next();
    if (needRemove(item)) {
        it.remove(); // 唯一安全的遍历时删除方式
    }
}

在并发修改场景下，其他遍历方式会抛出ConcurrentModificationException，而Iterator的remove()方法通过维护expectedModCount实现安全删除。

1.2 高级遍历方案

ListIterator是Iterator的增强版，专为List设计：

java复制ListIterator<Item> lit = list.listIterator();
while (lit.hasNext()) {
    Item item = lit.next();
    if (needInsertBefore(item)) {
        lit.previous(); // 回退
        lit.add(newItem); // 插入
    }
}

特别适合需要双向遍历或中间插入的场景。我在实现文本编辑器时就用它来处理行级操作。

forEach+Lambda是JDK8引入的函数式风格：

java复制list.forEach(item -> process(item));

简洁但功能有限，无法使用break/return控制流程。在简单的日志打印等场景非常适用。

Stream API提供了声明式处理能力：

java复制list.stream()
    .filter(item -> item.isValid())
    .map(item -> item.transform())
    .forEach(item -> store(item));

适合复杂的数据处理流水线。我曾用parallelStream()处理10万级数据，性能提升3倍（但要注意线程安全问题）。

2. 深度对比与性能实测

2.1 功能对比矩阵

2.2 性能基准测试

使用JMH对ArrayList和LinkedList进行百万次遍历测试（单位：ms）：

关键发现：LinkedList绝对不要用普通for循环！parallelStream在小数据量时反而更慢。

3. 实战经验与避坑指南

3.1 ConcurrentModificationException详解

这个异常是Java集合的fail-fast机制导致的，常见于：

java复制for (Item item : list) {
    if (condition(item)) {
        list.remove(item); // 抛出异常
    }
}

解决方案：

1. 使用Iterator.remove()
2. 使用CopyOnWriteArrayList等并发集合
3. 先记录要删除的元素，遍历后统一删除

3.2 Stream使用陷阱

1. 重复使用问题：

java复制Stream<Item> stream = list.stream();
stream.filter(...); // 操作1
stream.map(...);    // 抛出IllegalStateException

Stream是单向的，操作后即关闭。

2. 性能陷阱：

java复制list.stream()
    .filter(item -> heavyOperation(item)) // 耗时操作
    .findFirst();

应该改为：

java复制list.stream()
    .filter(item -> lightOperation(item))
    .findFirst()
    .ifPresent(item -> heavyOperation(item));

3.3 最佳实践建议

1. 基础选择原则：

• 只需要遍历：增强for循环
• 需要删除：Iterator
• 需要索引：普通for（仅ArrayList）
• 复杂处理：Stream

2. 性能优化技巧：

• 对ArrayList，普通for循环最快
• 大数据量考虑parallelStream
• 避免在Stream中间操作中进行IO操作

3. 代码可读性：

• 简单的遍历用增强for
• 复杂的业务逻辑用Stream+方法引用

java复制orders.stream()
      .filter(Order::isValid)
      .map(Order::calculate)
      .forEach(this::save);

4. 特殊集合的遍历方案

4.1 Map的遍历方式

1. entrySet遍历（效率最高）：

java复制for (Map.Entry<K,V> entry : map.entrySet()) {
    K key = entry.getKey();
    V value = entry.getValue();
}

2. Java8 forEach：

java复制map.forEach((k,v) -> process(k,v));

4.2 并发集合遍历

CopyOnWriteArrayList的Iterator不会抛出ConcurrentModificationException，但反映的是创建迭代器时的集合状态：

java复制// 线程安全但可能不是最新数据
for (Item item : copyOnWriteList) {
    // 其他线程的修改不会影响本次遍历
}

4.3 自定义集合遍历

实现Iterable接口可以支持增强for循环：

java复制public class MyCollection<E> implements Iterable<E> {
    // 实现iterator()方法
    @Override
    public Iterator<E> iterator() {
        return new MyIterator();
    }
}

5. Java8+新特性应用

5.1 Stream的懒加载机制

Stream的操作分为中间操作和终端操作，只有终端操作才会触发实际计算：

java复制list.stream()
    .peek(System.out::println) // 不会执行
    .count(); // 触发执行

5.2 并行流注意事项

1. 确保操作是线程安全的
2. 避免共享可变状态
3. 合理使用collectors.toConcurrentMap等并发收集器

5.3 Java9+增强

takeWhile/dropWhile操作：

java复制list.stream()
    .takeWhile(item -> item.isValid()) // 遇到false停止
    .forEach(...);

6. 常见问题解决方案

6.1 遍历时修改元素属性

这是安全的，不会触发ConcurrentModificationException：

java复制for (Item item : list) {
    item.setName("new"); // 允许
}

6.2 嵌套集合遍历优化

使用flatMap简化嵌套循环：

java复制List<List<Item>> nestedList = ...;
nestedList.stream()
          .flatMap(List::stream)
          .forEach(...);

6.3 超大集合遍历

1. 分批处理：

java复制int batchSize = 1000;
for (int i = 0; i < list.size(); i += batchSize) {
    List<Item> batch = list.subList(i, Math.min(i + batchSize, list.size()));
    processBatch(batch);
}

2. 使用Spliterator手动控制：

java复制Spliterator<Item> spliterator = list.spliterator();
spliterator.tryAdvance(item -> process(item));

7. 性能优化深度实践

7.1 避免装箱拆箱

对于基本类型集合，使用专门API：

java复制IntList intList = ...;
intList.forEachInt(i -> process(i)); // 比forEach(Object)更高效

7.2 预分配空间

对于要收集结果的遍历：

java复制List<Result> results = new ArrayList<>(list.size()); // 避免扩容
for (Item item : list) {
    results.add(process(item));
}

7.3 方法内联优化

高频遍历代码考虑方法内联：

java复制// 热代码中避免这样的方法调用
list.forEach(this::processItem);

// 改为直接内联
for (Item item : list) {
    // 直接处理逻辑
}

8. 设计模式应用

8.1 迭代器模式

自定义迭代器实现特殊遍历逻辑：

java复制public class TreeIterator implements Iterator<Node> {
    // 实现深度优先或广度优先遍历
}

8.2 访问者模式

将遍历与处理逻辑解耦：

java复制public interface Visitor {
    void visit(Item item);
}

public void traverse(Visitor visitor) {
    for (Item item : collection) {
        visitor.visit(item);
    }
}

9. 工程化建议

1. 代码审查重点：

• 检查LinkedList是否被误用普通for循环
• 并行流是否处理了线程安全问题
• 遍历过程中是否有意外的集合修改

2. 测试策略：

• 对空集合、单元素集合、大集合分别测试
• 并发修改场景的异常测试
• Stream的懒加载特性测试

3. 文档规范：

• 在集合类文档中注明推荐的遍历方式
• 对性能敏感的遍历方式添加注释说明

10. 未来演进方向

1. Java16引入的Stream.mapMulti：

java复制stream.mapMulti((item, consumer) -> {
    if (item.isValid()) {
        consumer.accept(item.transform());
    }
});

2. Java21虚拟线程与遍历：
   虚拟线程可以更高效地处理IO密集型遍历操作。

3. 值类型集合：
   Valhalla项目将引入专门的值类型集合，可能带来新的遍历模式。

在实际项目中，我通常会根据代码审查需要建立遍历方式的检查清单：

• 是否需要随机访问？
• 是否需要修改集合？
• 数据量大小如何？
• 是否需要并行处理？
• 代码可读性要求？

记住没有放之四海而皆准的最佳方案，只有最适合当前场景的选择。经过多次性能调优的经验告诉我，有时候最简单的增强for循环反而是最优解。