Java集合遍历的8种方式及性能优化

1. Java集合遍历的8种方式详解

在Java开发中，集合遍历是最基础也最频繁使用的操作之一。很多初学者可能只熟悉for循环和迭代器这两种方式，但实际上Java提供了至少8种不同的集合遍历方法，每种方法都有其适用场景和性能特点。掌握这些遍历方式不仅能提升代码效率，还能让代码更加简洁优雅。

1.1 为什么需要多种遍历方式

不同的遍历方式在代码可读性、性能、线程安全等方面各有优劣。比如在遍历过程中需要删除元素时，使用迭代器是最安全的选择；而只需要读取元素时，增强for循环则更加简洁。了解这些方法的区别，可以帮助我们在不同场景下选择最合适的遍历方式。

2. 8种集合遍历方式详解

2.1 传统for循环遍历

最基本的遍历方式，通过索引访问集合元素：

java复制List<String> list = new ArrayList<>();
// 添加元素...

for(int i=0; i<list.size(); i++) {
    String item = list.get(i);
    System.out.println(item);
}

特点：

• 适用于ArrayList等实现了RandomAccess接口的集合
• 可以通过索引直接访问任意位置的元素
• 遍历过程中可以修改元素（但不能增删元素）

注意：LinkedList等未实现RandomAccess接口的集合使用这种方式性能较差，因为get(i)需要从头遍历到第i个元素。

2.2 迭代器遍历

使用Iterator接口遍历集合：

java复制Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
    String item = iterator.next();
    System.out.println(item);
}

特点：

• 适用于所有Collection集合
• 遍历过程中可以安全地删除元素（使用iterator.remove()）
• 是线程安全的遍历方式（如果集合本身是线程安全的）

2.3 增强for循环（foreach）

Java 5引入的语法糖，底层使用迭代器实现：

java复制for(String item : list) {
    System.out.println(item);
}

特点：

• 代码简洁，可读性好
• 遍历过程中不能修改集合结构（增删元素）
• 适用于所有实现了Iterable接口的集合

2.4 ListIterator遍历

List特有的双向遍历迭代器：

java复制ListIterator<String> listIterator = list.listIterator();
while(listIterator.hasNext()) {
    String item = listIterator.next();
    System.out.println(item);
}

// 也可以反向遍历
while(listIterator.hasPrevious()) {
    String item = listIterator.previous();
    System.out.println(item);
}

特点：

• 可以双向遍历
• 可以在遍历过程中添加、修改、删除元素
• 可以获取当前元素的索引

2.5 forEach方法（Java 8+）

使用Collection接口的forEach方法：

java复制list.forEach(item -> System.out.println(item));

特点：

• 代码简洁，函数式风格
• 内部使用增强for循环实现
• 不能使用break/continue控制流程

2.6 Stream API遍历（Java 8+）

使用Stream API进行遍历和操作：

java复制list.stream()
    .filter(item -> item.startsWith("A"))
    .forEach(System.out::println);

特点：

• 支持链式操作和函数式编程
• 可以进行过滤、映射等中间操作
• 适合复杂的数据处理场景

2.7 并行流遍历（Java 8+）

使用并行流提高遍历效率：

java复制list.parallelStream()
    .forEach(item -> System.out.println(item));

特点：

• 利用多核CPU提高处理速度
• 适合大数据量且无顺序要求的场景
• 需要注意线程安全问题

2.8 Enumeration遍历（遗留方式）

主要用于Vector和Hashtable等遗留集合：

java复制Vector<String> vector = new Vector<>();
// 添加元素...

Enumeration<String> enumeration = vector.elements();
while(enumeration.hasMoreElements()) {
    String item = enumeration.nextElement();
    System.out.println(item);
}

特点：

• 主要用于兼容老代码
• 功能比Iterator简单
• 不支持remove操作

3. 不同场景下的选择建议

3.1 需要修改集合结构时

优先使用Iterator或ListIterator，这是唯一安全地在遍历过程中删除元素的方式。其他方式在遍历时修改集合结构会抛出ConcurrentModificationException。

3.2 只需要读取元素时

增强for循环或forEach方法是最简洁的选择，代码可读性最好。

3.3 需要处理大数据量时

考虑使用并行流，但要注意：

1. 数据量足够大才有性能优势
2. 操作必须是线程安全的
3. 元素的处理顺序不重要

3.4 需要复杂数据处理时

Stream API提供了丰富的中间操作（filter、map、sorted等），适合复杂的数据处理流水线。

4. 性能比较与实测数据

我们对ArrayList和LinkedList分别测试了不同遍历方式的性能（单位：纳秒/元素）：

*并行流测试使用4核CPU

从测试结果可以看出：

1. 对于ArrayList，传统for循环最快，因为可以直接通过索引访问元素
2. 对于LinkedList，迭代器方式明显优于传统for循环
3. 并行流在大数据量时能显著提高性能

5. 常见问题与解决方案

5.1 ConcurrentModificationException异常

问题现象：
在遍历集合时修改集合结构（增删元素），会抛出此异常。

解决方案：

1. 使用Iterator的remove方法删除元素
2. 如果要添加元素，可以先记录要添加的元素，遍历完成后再添加
3. 使用CopyOnWriteArrayList等并发集合

5.2 遍历Map集合的特殊方式

Map的遍历有几种特殊方式：

java复制Map<String, Integer> map = new HashMap<>();

// 遍历键
for(String key : map.keySet()) {
    System.out.println(key);
}

// 遍历值
for(Integer value : map.values()) {
    System.out.println(value);
}

// 遍历键值对
for(Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// Java 8方式
map.forEach((k, v) -> System.out.println(k + ": " + v));

5.3 遍历过程中的性能优化

1. 对于ArrayList，预先计算size可以避免多次调用方法：

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

2. 使用Iterator时，如果只需要读取元素，可以用增强for循环代替，代码更简洁

3. 大数据量遍历时，考虑使用并行流，但要注意线程安全问题

6. 实际开发中的经验分享

1. 代码可读性优先：在大多数情况下，增强for循环或forEach方法的可读性最好，应优先考虑。

2. 注意集合的具体实现：ArrayList和LinkedList的最佳遍历方式不同，要根据集合类型选择合适的方式。

3. Java 8+项目的选择：在新项目中，可以多用Stream API，它提供了更强大的数据处理能力。

4. 并行处理的陷阱：并行流不是万能的，小数据量时反而可能更慢，且要注意线程安全问题。

5. 遍历时的资源释放：如果遍历过程中需要操作资源（如IO流），确保在finally块中正确释放。

6. 自定义集合的遍历：如果实现自定义集合类，记得正确实现Iterable接口和iterator()方法。

7. 遍历的边界检查：使用传统for循环时，注意不要越界访问；使用迭代器时，确保在调用next()前检查hasNext()。

掌握这些集合遍历方式，能够让你在Java开发中更加游刃有余。根据具体场景选择最合适的遍历方法，既能提高代码效率，也能让代码更加清晰易维护。