1. 引言

在Java編程中，for循環(huán)是遍歷集合（如List、Set）的常用方式。然而，許多開發(fā)者在循環(huán)內部直接對集合進行增刪改操作時，往往會遇到ConcurrentModificationException異常。例如：

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
for (Integer num : numbers) {
    if (num % 2 == 0) {
        numbers.remove(num); // 拋出ConcurrentModificationException
    }
}

本文將深入探討Java集合在循環(huán)中修改的問題，分析fail-fast機制，并提供線程安全的修改方案。

2. 問題現(xiàn)象：為什么在for循環(huán)中修改集合會出錯？

2.1 典型錯誤示例

（1）增強for循環(huán)刪除元素

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (String s : list) {
    if (s.equals("B")) {
        list.remove(s); // 拋出ConcurrentModificationException
    }
}

異常原因：Java的for-each循環(huán)使用Iterator，直接修改集合會導致迭代器狀態(tài)不一致。

（2）普通for循環(huán)刪除元素（可能出錯）

List<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
for (int i = 0; i < nums.size(); i++) {
    if (nums.get(i) % 2 == 0) {
        nums.remove(i); // 可能導致元素跳過
    }
}
// 結果可能是 [1, 3, 4] 而非預期的 [1, 3]

問題：刪除元素后列表大小變化，但循環(huán)索引繼續(xù)遞增，導致某些元素被跳過。

3. 深入分析：Java集合的fail-fast機制

3.1 什么是fail-fast？

Java的ArrayList、HashSet等非線程安全集合采用fail-fast機制：

當?shù)鳈z測到集合被并發(fā)修改（即非通過迭代器自身的方法修改），立即拋出ConcurrentModificationException。

目的是快速失敗，避免潛在的數(shù)據不一致問題。

3.2 源碼分析

以ArrayList為例，其Iterator實現(xiàn)會檢查modCount（修改計數(shù)器）：

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

modCount：集合結構修改次數(shù)（如add、remove）。

expectedModCount：迭代器預期的修改次數(shù)。

直接調用list.remove()會修改modCount，導致與expectedModCount不一致。

4. 解決方案：安全修改集合的幾種方法

4.1 方法1：使用Iterator的remove()方法（推薦）

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    Integer num = it.next();
    if (num % 2 == 0) {
        it.remove(); // 安全刪除
    }
}
System.out.println(numbers); // [1, 3]

優(yōu)點：

迭代器自身維護modCount，不會觸發(fā)異常。

適用于單線程環(huán)境。

4.2 方法2：使用Java 8+的removeIf()

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
numbers.removeIf(num -> num % 2 == 0);
System.out.println(numbers); // [1, 3]

優(yōu)點：

代碼簡潔，內部使用Iterator實現(xiàn)。

性能較好。

4.3 方法3：使用CopyOnWriteArrayList（線程安全）

List<Integer> numbers = new CopyOnWriteArrayList<>(Arrays.asList(1, 2, 3, 4));
for (Integer num : numbers) {
    if (num % 2 == 0) {
        numbers.remove(num); // 安全但性能較低
    }
}
System.out.println(numbers); // [1, 3]

適用場景：

多線程環(huán)境。

缺點：每次修改會復制整個數(shù)組，性能較差。

4.4 方法4：普通for循環(huán)反向遍歷

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
for (int i = numbers.size() - 1; i >= 0; i--) {
    if (numbers.get(i) % 2 == 0) {
        numbers.remove(i); // 避免索引錯位
    }
}
System.out.println(numbers); // [1, 3]

優(yōu)點：

無需額外迭代器或副本。

適用于簡單刪除邏輯。

4.5 方法5：記錄待刪除元素，最后批量刪除

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
List<Integer> toRemove = new ArrayList<>();
for (Integer num : numbers) {
    if (num % 2 == 0) {
        toRemove.add(num);
    }
}
numbers.removeAll(toRemove);
System.out.println(numbers); // [1, 3]

適用場景：

需要復雜條件判斷時。

缺點：需要額外空間存儲待刪除元素。

5. 性能對比：不同方法的效率分析

結論：

單線程下優(yōu)先選擇Iterator.remove()或removeIf()。

多線程環(huán)境使用CopyOnWriteArrayList或加鎖。

大數(shù)據量避免CopyOnWriteArrayList，選擇Iterator或反向遍歷。

6. 最佳實踐總結

禁止在增強for循環(huán)中直接修改集合，改用Iterator.remove()。

Java 8+推薦removeIf()，代碼更簡潔。

多線程環(huán)境使用并發(fā)集合（如CopyOnWriteArrayList）或同步塊。

大規(guī)模數(shù)據刪除優(yōu)先選擇Iterator或反向遍歷。

復雜條件刪除可先記錄元素，再批量刪除。

7. 結論

在Java中，直接于for循環(huán)內修改集合會觸發(fā)ConcurrentModificationException，根源在于fail-fast機制。
安全修改集合的最佳實踐包括：

• 單線程：Iterator.remove()或removeIf()
• 多線程：CopyOnWriteArrayList或同步控制

掌握這些方法后，可以避免常見陷阱，寫出更健壯的Java代碼。 

到此這篇關于Java中for循環(huán)內修改集合的常見陷阱與最佳實踐的文章就介紹到這了,更多相關Java for循環(huán)內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論