Java-ArrayList集合的遍历方式详解
- 二、ArrayList概述
- 三、ArrayList的遍历方式
- 1. 普通for循环遍历
- 2. 增强for循环遍历
- 3. 迭代器遍历
- 4. ListIterator遍历
- 5. Java 8 Stream API遍历
- 四、性能对比与分析
- 性能测试结果分析
- 五、遍历方式的选择建议
- 六、常见遍历陷阱与注意事项
- 1. 并发修改异常（ConcurrentModificationException）
- 2. 迭代器失效问题
- 3. 并行流的线程安全问题
- 总结
Java中ArrayList是常用的数据结构之一，它基于动态数组实现，允许我们存储和操作对象集合。对ArrayList进行遍历是日常开发中频繁使用的操作，但遍历方式多种多样，不同场景下选择合适的遍历方式至关重要。本文我将详细介绍ArrayList的各种遍历方式、性能对比及适用场景，帮你在实际项目中做出最优选择。
二、ArrayList概述
ArrayList是Java集合框架中List接口的一个实现类，位于java.util包下。它的底层是基于动态数组实现的，这意味着它可以根据元素的数量自动调整容量。与传统数组相比，ArrayList的容量可以动态增长，提供了更灵活的元素存储方式。
下面是一个简单创建和使用ArrayList的示例：
import java.util.ArrayList;
import java.util.List;public class ArrayListDemo {public static void main(String[] args) {// 创建ArrayList实例List<String> list = new ArrayList<>();// 添加元素list.add("Java");list.add("Python");list.add("C++");// 访问元素System.out.println("第一个元素：" + list.get(0));// 修改元素list.set(1, "JavaScript");// 删除元素list.remove(2);// 打印ArrayListSystem.out.println("ArrayList内容：" + list);}
}
ArrayList的特点包括：
- 允许存储null元素
- 元素有序且可重复
- 动态扩容，无需手动管理容量
- 支持随机访问，通过索引快速访问元素
三、ArrayList的遍历方式
1. 普通for循环遍历
普通for循环是最基本的遍历方式，通过控制索引来访问ArrayList中的每个元素。
import java.util.ArrayList;
import java.util.List;public class ForLoopTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 普通for循环遍历for (int i = 0; i < list.size(); i++) {System.out.println("元素" + i + "：" + list.get(i));}}
}
优点：
- 可以精确控制遍历的起始和结束位置
- 支持双向遍历（修改索引的递增方式）
- 可以在遍历过程中修改元素（通过set方法）
缺点：
- 代码相对繁琐，需要手动管理索引
- 如果不注意索引范围，容易出现IndexOutOfBoundsException异常
2. 增强for循环遍历
增强for循环（也称为foreach循环）是Java 5引入的语法糖，用于简化集合和数组的遍历。
import java.util.ArrayList;
import java.util.List;public class EnhancedForLoopTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 增强for循环遍历for (String fruit : list) {System.out.println("水果：" + fruit);}}
}
优点：
- 代码简洁，减少了样板代码
- 提高了代码的可读性
- 避免了索引越界的风险
缺点：
- 无法获取当前元素的索引（除非使用额外的计数器）
- 不支持在遍历过程中修改集合结构（如添加、删除元素）
- 只能单向遍历
3. 迭代器遍历
迭代器（Iterator）是Java集合框架提供的一种标准遍历机制，所有实现了Collection接口的集合类都支持迭代器。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class IteratorTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 获取迭代器Iterator<String> iterator = list.iterator();// 使用迭代器遍历while (iterator.hasNext()) {String fruit = iterator.next();System.out.println("水果：" + fruit);// 可以安全地删除当前元素if ("Banana".equals(fruit)) {iterator.remove();}}System.out.println("删除后的列表：" + list);}
}
优点：
- 提供了统一的遍历接口，适用于所有实现了Collection接口的集合
- 支持在遍历过程中安全地删除元素（通过Iterator的remove方法）
缺点：
- 代码相对冗长
- 只能单向遍历
- 性能略低于普通for循环
4. ListIterator遍历
ListIterator是Iterator的子接口，专门用于遍历List集合，提供了比Iterator更丰富的功能。
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;public class ListIteratorTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 获取ListIterator（从列表开头开始）ListIterator<String> listIterator = list.listIterator();// 正向遍历System.out.println("正向遍历：");while (listIterator.hasNext()) {System.out.println("水果：" + listIterator.next());}// 反向遍历（需要先将指针移到末尾）System.out.println("\n反向遍历：");while (listIterator.hasPrevious()) {System.out.println("水果：" + listIterator.previous());}// 在遍历过程中添加元素listIterator = list.listIterator();while (listIterator.hasNext()) {String fruit = listIterator.next();if ("Banana".equals(fruit)) {listIterator.add("Orange");}}System.out.println("\n添加后的列表：" + list);}
}
优点：
- 支持双向遍历（向前和向后）
- 支持在遍历过程中添加、修改和删除元素
- 可以获取当前元素的索引位置
缺点：
- 只能用于List集合，通用性不如Iterator
- 代码相对复杂，使用场景相对有限
5. Java 8 Stream API遍历
Java 8引入的Stream API提供了一种函数式编程风格的集合处理方式，可以更简洁地实现集合的遍历和处理。
import java.util.ArrayList;
import java.util.List;public class StreamApiTraversal {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 使用Stream API的forEach方法遍历System.out.println("使用Stream API遍历：");list.stream().forEach(fruit -> {System.out.println("水果：" + fruit);});// 过滤并遍历（只打印长度大于5的水果）System.out.println("\n过滤后的结果：");list.stream().filter(fruit -> fruit.length() > 5).forEach(fruit -> System.out.println("水果：" + fruit));// 并行流遍历（适用于大数据量并行处理）System.out.println("\n使用并行流遍历：");list.parallelStream().forEach(fruit -> {System.out.println("水果：" + fruit + "（线程：" + Thread.currentThread().getName() + "）");});}
}
优点：
- 代码简洁，支持链式操作
- 支持函数式编程风格，提高代码可读性
- 可以方便地进行过滤、映射、聚合等操作
- 并行流支持多线程并行处理，提高大数据量下的处理效率
缺点：
- 对于简单的遍历场景，可能显得过于重量级
- 并行流在某些场景下可能引入线程安全问题和额外的开销
- 调试相对困难
四、性能对比与分析
不同的遍历方式在性能上可能存在差异，特别是在处理大量数据时。下面通过一个简单的性能测试来比较各种遍历方式的执行时间。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;public class PerformanceComparison {public static void main(String[] args) {// 创建一个包含100万个元素的ArrayListList<Integer> list = new ArrayList<>();for (int i = 0; i < 1000000; i++) {list.add(i);}// 测试普通for循环遍历long startTime = System.currentTimeMillis();for (int i = 0; i < list.size(); i++) {list.get(i);}long endTime = System.currentTimeMillis();System.out.println("普通for循环遍历耗时：" + (endTime - startTime) + "ms");// 测试增强for循环遍历startTime = System.currentTimeMillis();for (Integer num : list) {// 空循环，仅测试遍历时间}endTime = System.currentTimeMillis();System.out.println("增强for循环遍历耗时：" + (endTime - startTime) + "ms");// 测试迭代器遍历startTime = System.currentTimeMillis();Iterator<Integer> iterator = list.iterator();while (iterator.hasNext()) {iterator.next();}endTime = System.currentTimeMillis();System.out.println("迭代器遍历耗时：" + (endTime - startTime) + "ms");// 测试ListIterator遍历startTime = System.currentTimeMillis();ListIterator<Integer> listIterator = list.listIterator();while (listIterator.hasNext()) {listIterator.next();}endTime = System.currentTimeMillis();System.out.println("ListIterator遍历耗时：" + (endTime - startTime) + "ms");// 测试Stream API遍历startTime = System.currentTimeMillis();list.stream().forEach(num -> {// 空处理，仅测试遍历时间});endTime = System.currentTimeMillis();System.out.println("Stream API遍历耗时：" + (endTime - startTime) + "ms");// 测试并行流遍历startTime = System.currentTimeMillis();list.parallelStream().forEach(num -> {// 空处理，仅测试遍历时间});endTime = System.currentTimeMillis();System.out.println("并行流遍历耗时：" + (endTime - startTime) + "ms");}
}
性能测试结果分析
在不同的测试环境下，各种遍历方式的性能表现可能有所不同，但通常可以得出以下结论：
-
普通for循环在处理ArrayList时性能最优，因为它直接通过索引访问元素，没有额外的开销。
-
增强for循环和迭代器遍历的性能接近，它们在底层实现上是相似的。增强for循环实际上是迭代器的语法糖。
-
ListIterator遍历的性能略低于普通迭代器，因为它提供了更多的功能。
-
Stream API遍历的性能在处理小数据量时与增强for循环接近，但在大数据量下可能略慢。
-
并行流遍历在多核处理器上处理大数据量时性能优势明显，但在小数据量或单核处理器上可能表现更差，因为并行流需要创建和管理线程池，带来额外的开销。
五、遍历方式的选择建议
根据不同的场景和需求，可以选择合适的遍历方式：
-
如果需要在遍历过程中修改集合结构（添加、删除元素），可以使用迭代器（Iterator或ListIterator）。特别是ListIterator支持在遍历过程中添加、修改和删除元素。
-
如果需要双向遍历，只能使用ListIterator。
-
如果代码简洁性是首要考虑，增强for循环是不错的选择。它适用于简单的遍历场景，不需要索引和修改集合结构的情况。
-
如果需要对元素进行复杂的处理或聚合操作，Stream API提供了更强大和灵活的功能。它支持过滤、映射、排序、聚合等操作，可以使代码更加简洁和可读。
-
如果处理的数据量很大且在多核处理器上运行，可以考虑使用并行流提高性能。但要注意并行流可能引入的线程安全问题。
-
如果追求极致性能，特别是在处理大量数据时，普通for循环是最佳选择。
六、常见遍历陷阱与注意事项
1. 并发修改异常（ConcurrentModificationException）
在使用增强for循环或迭代器遍历集合时，如果在遍历过程中修改集合结构（添加、删除元素），会抛出ConcurrentModificationException异常。
import java.util.ArrayList;
import java.util.List;public class ConcurrentModificationExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 错误示例：使用增强for循环删除元素try {for (String fruit : list) {if ("Banana".equals(fruit)) {list.remove(fruit); // 会抛出ConcurrentModificationException}}} catch (Exception e) {e.printStackTrace();}// 正确示例：使用迭代器删除元素list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");java.util.Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String fruit = iterator.next();if ("Banana".equals(fruit)) {iterator.remove(); // 安全删除元素}}System.out.println("删除后的列表：" + list);}
}
2. 迭代器失效问题
在使用迭代器遍历集合时，如果通过集合本身的方法（而不是迭代器的方法）修改集合结构，会导致迭代器失效。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class IteratorInvalidationExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");Iterator<String> iterator = list.iterator();while (iterator.hasNext()) {String fruit = iterator.next();if ("Banana".equals(fruit)) {// 错误：使用集合的remove方法，而不是迭代器的remove方法list.remove(fruit); // 会导致迭代器失效}}}
}
3. 并行流的线程安全问题
在使用并行流处理集合时，如果操作共享资源，需要注意线程安全问题。
import java.util.ArrayList;
import java.util.List;public class ParallelStreamThreadSafety {public static void main(String[] args) {List<Integer> list = new ArrayList<>();for (int i = 0; i < 1000; i++) {list.add(i);}// 非线程安全的累加器int sum = 0;// 错误示例：并行流中修改非线程安全的共享变量list.parallelStream().forEach(num -> {sum += num; // 线程不安全的操作});System.out.println("错误的累加结果：" + sum); // 结果可能不正确// 正确示例：使用线程安全的累加器java.util.concurrent.atomic.AtomicInteger safeSum = new java.util.concurrent.atomic.AtomicInteger(0);list.parallelStream().forEach(num -> {safeSum.addAndGet(num); // 线程安全的操作});System.out.println("正确的累加结果：" + safeSum.get());}
}
总结
本文我详细介绍了Java中ArrayList集合的多种遍历方式：普通for循环、增强for循环、迭代器、ListIterator、Stream API和并行流。每种遍历方式都有其特点和适用场景，应根据具体需求选择合适的遍历方式。
在实际开发中，除了考虑功能需求外，还应关注代码的性能和可读性。对于简单的遍历场景，建议优先使用增强for循环或Stream API；对于需要高性能的大数据量处理，普通for循环或并行流是更好的选择；而在需要灵活控制遍历过程的场景下，迭代器或ListIterator则更为合适。
若这篇内容帮到你，动动手指支持下！关注不迷路，干货持续输出！
ヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉ
