在Java开发中，
foreach循环以其简洁的语法和易用性，成为了遍历集合和数组的首选方式。然而，正如硬币有两面，foreach循环在带来便利的同时，也隐藏着一些鲜为人知的“陷阱”。这些陷阱如果处理不当，轻则导致程序行为异常，重则引发难以调试的ConcurrentModificationException。本文将探讨foreach循环的常见陷阱，并提供规避这些问题的最佳实践。
1. 陷阱一：集合修改引发的ConcurrentModificationException
ConcurrentModificationException是foreach循环中最常见也是最令人头疼的陷阱。当你在foreach循环遍历集合时，同时对集合进行结构性修改（例如添加、删除元素），就会抛出此异常。这是因为foreach循环底层是基于迭代器（Iterator）实现的，迭代器在创建时会记录集合的修改次数（modCount）。如果在遍历过程中modCount发生变化，而迭代器没有感知到，就会在下一次操作时抛出ConcurrentModificationException，以避免不确定的行为。
示例代码：
import java.util.ArrayList;
import java.util.List;
public class ForeachPitfall1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
// 错误示例：在foreach循环中删除元素
try {
for (String s : list) {
if ("B".equals(s)) {
list.remove(s);
}
}
} catch (Exception e) {
System.out.println("捕获到异常: " + e.getClass().getSimpleName());
}
System.out.println("修改后的列表: " + list);
}
}
运行结果：
捕获到异常: ConcurrentModificationException
修改后的列表: [A, C]
规避方法：
-
使用迭代器（Iterator）的
remove()方法： 这是最推荐和安全的做法。迭代器提供了remove()方法，可以在遍历过程中安全地删除当前元素。import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ForeachPitfall1Solution1 { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C"); list.add("D"); Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String s = iterator.next(); if ("B".equals(s)) { iterator.remove(); // 安全删除 } } System.out.println("修改后的列表: " + list); } } -
使用传统的
for循环： 如果需要根据索引进行操作，或者在遍历过程中添加元素，传统的for循环可以提供更大的灵活性。但需要注意，删除元素时要小心索引的变化。import java.util.ArrayList; import java.util.List; public class ForeachPitfall1Solution2 { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C"); list.add("D"); for (int i = 0; i < list.size(); i++) { if ("B".equals(list.get(i))) { list.remove(i); i--; // 删除元素后，索引需要回退 } } System.out.println("修改后的列表: " + list); } } -
使用Java 8 Stream API： 对于过滤和转换操作，Stream API提供了更函数式和简洁的解决方案，且不会引发
ConcurrentModificationException。import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; public class ForeachPitfall1Solution3 { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C"); list.add("D"); List<String> newList = list.stream() .filter(s -> !"B".equals(s)) .collect(Collectors.toList()); System.out.println("修改后的列表: " + newList); } }
2. 陷阱二：无法修改集合元素本身（基本类型和不可变对象）
foreach循环在遍历集合时，实际上是获取了集合中元素的副本（对于基本类型）或者引用（对于对象）。这意味着，你无法在foreach循环中直接修改集合中基本类型元素的值，也无法替换集合中的不可变对象实例。
示例代码：
import java.util.ArrayList;
import java.util.List;
public class ForeachPitfall2 {
public static void main(String[] args) {
// 示例1：基本类型
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("修改前 (基本类型): " + numbers);
for (Integer num : numbers) {
num = num * 2; // 尝试修改元素的值，但实际上修改的是副本
}
System.out.println("修改后 (基本类型): " + numbers);
// 示例2：不可变对象 (String)
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
System.out.println("修改前 (不可变对象): " + names);
for (String name : names) {
name = name.toUpperCase(); // 尝试修改元素的值，但实际上是创建了新String对象，原集合元素未变
}
System.out.println("修改后 (不可变对象): " + names);
}
}
运行结果：
修改前 (基本类型): [1, 2, 3]
修改后 (基本类型): [1, 2, 3]
修改前 (不可变对象): [Alice, Bob]
修改后 (不可变对象): [Alice, Bob]
规避方法：
-
使用传统的
for循环和set()方法： 如果需要修改集合中元素的值或替换不可变对象，可以使用传统的for循环结合List的set()方法。import java.util.ArrayList; import java.util.List; public class ForeachPitfall2Solution1 { public static void main(String[] args) { List<Integer> numbers = new ArrayList<>(); numbers.add(1); numbers.add(2); numbers.add(3); for (int i = 0; i < numbers.size(); i++) { numbers.set(i, numbers.get(i) * 2); } System.out.println("修改后 (基本类型): " + numbers); List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); for (int i = 0; i < names.size(); i++) { names.set(i, names.get(i).toUpperCase()); } System.out.println("修改后 (不可变对象): " + names); } } -
使用Stream API进行转换： Stream API提供了
map操作，可以方便地对集合中的元素进行转换，并生成新的集合。import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; public class ForeachPitfall2Solution2 { public static void main(String[] args) { List<Integer> numbers = new ArrayList<>(); numbers.add(1); numbers.add(2); numbers.add(3); List<Integer> doubledNumbers = numbers.stream() .map(num -> num * 2) .collect(Collectors.toList()); System.out.println("修改后 (基本类型): " + doubledNumbers); List<String> names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); List<String> upperCaseNames = names.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.out.println("修改后 (不可变对象): " + upperCaseNames); } }
3. 陷阱三：性能考量与特定场景下的选择
虽然foreach循环在大多数情况下表现良好，但在某些特定场景下，其性能可能不如传统的for循环或Stream API。这主要体现在以下几个方面：
-
随机访问性能： 对于
ArrayList这类支持随机访问（通过索引直接获取元素）的集合，传统的for循环通过索引访问元素通常比foreach循环（底层仍依赖迭代器）更快。而对于LinkedList这类链表结构，foreach循环的性能则更优，因为它避免了传统for循环中每次get(i)操作都需要从头遍历的开销。 -
基本类型数组：
foreach循环在遍历基本类型数组时，性能与传统for循环几乎没有差异，因为它们都直接访问数组元素。 -
Stream API的惰性求值： Stream API在处理大量数据时，由于其惰性求值和并行处理的能力，在某些复杂操作（如过滤、映射、归约）上可能展现出更好的性能。但对于简单的遍历，Stream API可能会引入额外的开销。
示例代码（性能对比）：
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
public class ForeachPitfall3 {
private static final int SIZE = 200000;
public static void main(String[] args) {
List<Integer> arrayList = new ArrayList<>(SIZE);
List<Integer> linkedList = new LinkedList<>();
Random random = new Random();
for (int i = 0; i < SIZE; i++) {
int value = random.nextInt();
arrayList.add(value);
linkedList.add(value);
}
long startTime, endTime;
// ArrayList - 传统for循环
startTime = System.nanoTime();
for (int i = 0; i < arrayList.size(); i++) {
int value = arrayList.get(i);
}
endTime = System.nanoTime();
System.out.println("ArrayList (传统for循环): " + (endTime - startTime) / 1_000_000.0 + " ms");
// ArrayList - foreach循环
startTime = System.nanoTime();
for (Integer value : arrayList) {
}
endTime = System.nanoTime();
System.out.println("ArrayList (foreach循环): " + (endTime - startTime) / 1_000_000.0 + " ms");
// LinkedList - 传统for循环 (性能较差)
startTime = System.nanoTime();
for (int i = 0; i < linkedList.size(); i++) {
int value = linkedList.get(i);
}
endTime = System.nanoTime();
System.out.println("LinkedList (传统for循环): " + (endTime - startTime) / 1_000_000.0 + " ms");
// LinkedList - foreach循环
startTime = System.nanoTime();
for (Integer value : linkedList) {
}
endTime = System.nanoTime();
System.out.println("LinkedList (foreach循环): " + (endTime - startTime) / 1_000_000.0 + " ms");
// ArrayList - Stream forEach
startTime = System.nanoTime();
arrayList.forEach(value -> {});
endTime = System.nanoTime();
System.out.println("ArrayList (Stream forEach): " + (endTime - startTime) / 1_000_000.0 + " ms");
}
}
运行结果：
ArrayList (传统for循环): 3.016699 ms
ArrayList (foreach循环): 4.740699 ms
LinkedList (传统for循环): 23129.3813 ms
LinkedList (foreach循环): 8.8326 ms
ArrayList (Stream forEach): 7.8337 ms
规避方法：
选择合适的循环方式，需要根据具体的集合类型、操作需求和性能要求来决定：
- 优先使用
foreach： 对于大多数简单的遍历场景，foreach循环因其简洁性、可读性高而成为首选。 ArrayList等随机访问集合： 如果需要根据索引进行频繁的随机访问，或者在遍历过程中进行修改操作，传统for循环可能更合适。LinkedList等顺序访问集合：foreach循环或迭代器是遍历这类集合的最佳选择。- 复杂数据处理： 对于需要进行过滤、映射、归约等复杂操作，且数据量较大的场景，Stream API通常能提供更优雅和高效的解决方案。
4. 总结
foreach循环作为Java中遍历集合和数组的强大工具，极大地简化了代码。然而，作为一名Java开发工程师，我们必须清醒地认识到其潜在的“陷阱”。理解ConcurrentModificationException的根源，明确foreach循环无法直接修改集合元素本身的特性，并根据具体场景权衡不同循环方式的性能，是写出高质量Java代码的关键。
在实际开发中，我们应该：
- 避免在
foreach循环中修改集合结构，如果需要修改，请使用迭代器的remove()方法或传统的for循环。 - 明确
foreach循环的局限性，当需要修改集合元素值或替换不可变对象时，考虑使用传统for循环配合set()方法，或利用Stream API进行转换。 - 根据集合类型和操作需求选择最合适的循环方式，不要盲目地只使用
foreach。
通过掌握这些知识和最佳实践，我们可以更好地驾驭foreach循环，避免不必要的错误，并编写出更健壮、更高效的Java应用程序。
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
