本文深入探讨了在Java中对`ArrayList`进行迭代时，如何安全高效地执行添加、删除和修改操作，以避免`ConcurrentModificationException`。文章详细分析了不同迭代方式（如`Iterator`、`ListIterator`和增强型for循环）的适用场景、性能考量，并揭示了`synchronizedList`在多线程环境下提供线程安全性的局限性，强调了对可变对象进行全面同步的重要性。
1. 理解ConcurrentModificationException与迭代器
ConcurrentModificationException是Java集合框架中一个常见的运行时异常，它通常在迭代一个集合时，同时又通过集合自身的非迭代器方法修改了集合的结构（如添加或删除元素）时抛出。这是Java的“快速失败”（fail-fast）机制的一部分，旨在尽早发现并发修改问题。
在ArrayList的迭代过程中，无论是使用增强型for循环（底层也是通过Iterator实现）还是显式使用Iterator，如果直接调用ArrayList的add()或remove()方法来改变集合结构，都会导致迭代器检测到修改，并抛出ConcurrentModificationException。
2. 安全地移除ArrayList中的元素
在迭代ArrayList时移除元素，必须遵循特定规则以避免ConcurrentModificationException。
立即学习“Java免费学习笔记（深入）”；
2.1 使用Iterator.remove()
这是在迭代过程中安全移除元素的标准方法。Iterator接口提供了remove()方法，该方法在调用next()之后移除由next()返回的最后一个元素。
import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class ArrayListRemovalDemo { public static void main(String[] args) { List items = new ArrayList(); items.add("Apple"); items.add("Banana"); items.add("Cherry"); items.add("Date"); System.out.println("Original list: " + items); Iterator itemIterator = items.iterator(); while (itemIterator.hasNext()) { String item = itemIterator.next(); if (item.equals("Banana") || item.equals("Date")) { itemIterator.remove(); // 安全移除元素 } } System.out.println("List after Iterator.remove(): " + items); }}
性能考量：当在ArrayList的中间位置频繁调用Iterator.remove()时，每次移除操作都需要将该位置之后的所有元素向前移动一位。这在最坏情况下会导致O(n)的时间复杂度，如果在循环中执行k次移除操作，总复杂度可能达到O(n*k)，即平方级时间复杂度。对于大型列表和大量移除操作，这会严重影响性能。
2.2 使用Collection.removeIf()
Java 8引入的removeIf()方法提供了一种更高效、更简洁的批量移除方式。它接受一个Predicate函数式接口，并原子性地移除所有满足条件的元素。removeIf()在内部实现时会优化元素的移动过程，通常能达到线性时间复杂度。
import java.util.ArrayList;import java.util.List;public class ArrayListRemoveIfDemo { public static void main(String[] args) { List items = new ArrayList(); items.add("Apple"); items.add("Banana"); items.add("Cherry"); items.add("Date"); System.out.println("Original list: " + items); // 使用 removeIf 移除元素 items.removeIf(item -> item.equals("Banana") || item.equals("Date")); System.out.println("List after removeIf(): " + items); }}
优点： removeIf()通过内部迭代和延迟元素移动，将复杂度优化到线性时间O(n)，对于批量移除操作性能更优。
2.3 复制到新列表
如果需要移除的元素数量较多，或者逻辑复杂不便使用removeIf()，一个替代方案是创建一个新列表，并将需要保留的元素添加到新列表中。这种方法虽然会占用额外内存，但同样能保证线性时间复杂度。
import java.util.ArrayList;import java.util.List;import java.util.stream.Collectors;public class ArrayListCopyToNewListDemo { public static void main(String[] args) { List originalList = new ArrayList(); originalList.add("Apple"); originalList.add("Banana"); originalList.add("Cherry"); originalList.add("Date"); System.out.println("Original list: " + originalList); List newList = originalList.stream() .filter(item -> !item.equals("Banana") && !item.equals("Date")) .collect(Collectors.toList()); System.out.println("New list after filtering: " + newList); }}
3. 安全地向ArrayList中添加元素
在迭代ArrayList时添加元素比移除更复杂，因为标准的Iterator接口不提供添加方法。
3.1 使用ListIterator.add()
ListIterator是Iterator的子接口，专为List类型设计，提供了双向遍历和在迭代过程中添加、替换元素的能力。
瞬映
AI 快速创作数字人视频，一站式视频创作平台，让视频创作更简单。
57 查看详情 
import java.util.ArrayList;import java.util.List;import java.util.ListIterator;public class ArrayListAdditionDemo { public static void main(String[] args) { List items = new ArrayList(); items.add("Apple"); items.add("Banana"); items.add("Cherry"); System.out.println("Original list: " + items); ListIterator listIterator = items.listIterator(); while (listIterator.hasNext()) { String item = listIterator.next(); if (item.equals("Banana")) { listIterator.add("Orange"); // 在当前位置之后添加元素 } } System.out.println("List after ListIterator.add(): " + items); }}
性能考量：与Iterator.remove()类似，ListIterator.add()在ArrayList的中间位置添加元素时，需要将该位置之后的所有元素向后移动一位。这同样会导致O(n)的时间复杂度，在循环中频繁添加会产生平方级时间复杂度O(n*k)。
3.2 复制或构建新列表
如果需要在迭代过程中添加大量元素，并且这些添加操作发生在列表的任意位置，最有效的方法通常是构建一个新的列表。这种方法避免了ArrayList内部频繁的数组复制操作，从而保持线性时间复杂度。
import java.util.ArrayList;import java.util.List;public class ArrayListBuildNewListDemo { public static void main(String[] args) { List originalList = new ArrayList(); originalList.add("Apple"); originalList.add("Banana"); originalList.add("Cherry"); System.out.println("Original list: " + originalList); List newList = new ArrayList(); for (String item : originalList) { newList.add(item); // 添加原始元素 if (item.equals("Banana")) { newList.add("Orange"); // 根据条件添加新元素 } } System.out.println("New list after conditional additions: " + newList); }}
4. 修改ArrayList中现有元素的状态
与添加和删除操作不同，修改ArrayList中已存在元素的状态通常不会导致ConcurrentModificationException，因为这不涉及对列表结构的改变（即元素的增加或减少，或索引位置的变化）。
无论是使用增强型for循环还是显式Iterator，只要是修改Item对象本身的属性，而不是修改ArrayList的结构，都是安全的。
import java.util.ArrayList;import java.util.List;import java.util.Iterator;class Item { String name; boolean updated; public Item(String name) { this.name = name; this.updated = false; } public void update() { this.updated = true; System.out.println(name + " has been updated."); } @Override public String toString() { return "Item{" + "name='" + name + ''' + ", updated=" + updated + '}'; }}public class ArrayListModificationDemo { public static void main(String[] args) { List items = new ArrayList(); items.add(new Item("Apple")); items.add(new Item("Banana")); items.add(new Item("Cherry")); System.out.println("Original items: " + items); // 方式一：使用Iterator修改元素状态 Iterator itemIterator = items.iterator(); while (itemIterator.hasNext()) { Item item = itemIterator.next(); if (item.name.equals("Banana")) { item.update(); // 修改Item对象的状态 } } System.out.println("Items after Iterator modification: " + items); // 方式二：使用增强型for循环修改元素状态 for (Item item : items) { if (item.name.equals("Apple")) { item.update(); // 修改Item对象的状态 } } System.out.println("Items after enhanced for-loop modification: " + items); }}
性能与线程安全：
性能： 增强型for循环和显式Iterator循环在编译后对于简单的元素访问和内部状态修改，其字节码通常是相同的，因此在性能上没有显著差异。线程安全： 尽管修改元素状态不会引发ConcurrentModificationException，但这并不意味着它是线程安全的。ArrayList中存储的是对象的引用。当一个线程通过迭代器获取到Item对象的引用并修改其内部状态时，如果其他线程同时也在访问或修改同一个Item对象，就会出现竞态条件，导致数据不一致。要实现真正的线程安全，需要对Item对象的访问和修改进行同步保护。
5. synchronizedList的局限性与线程安全考量
Collections.synchronizedList()方法可以返回一个线程安全的List视图。它通过在每个方法调用上加锁来确保对列表的结构性操作（如add, remove, get, set等）是原子性的。
import java.util.ArrayList;import java.util.Collections;import java.util.List;public class SynchronizedListDemo { public static void main(String[] args) { List rawList = new ArrayList(); List synchronizedList = Collections.synchronizedList(rawList); // 结构性操作是线程安全的 synchronizedList.add("A"); synchronizedList.remove("A"); // 但迭代操作仍需手动同步 synchronized (synchronizedList) { for (String s : synchronizedList) { System.out.println(s); } } }}
局限性：
迭代仍需手动同步： synchronizedList只同步了其自身的方法调用。对于迭代操作，例如使用增强型for循环或Iterator，仍然需要在外部手动进行同步，以防止在迭代过程中发生其他线程修改列表结构的情况，否则仍可能抛出ConcurrentModificationException。不保护元素内容： synchronizedList只保证了对列表 结构 的线程安全，但它不保护列表中 存储的元素对象 本身的线程安全。如果ArrayList中存储的是可变对象（如上述Item类），并且多个线程同时获取到这些对象的引用并修改其内部状态，synchronizedList无法提供任何保护。要确保对可变元素的线程安全访问，需要额外的同步机制（例如在Item类内部的方法上加锁，或者在所有访问Item对象的地方使用外部锁）。
结论：synchronizedList在简单场景下（例如，列表中只包含不可变对象，且迭代操作总是被外部同步块包裹）可以提供基本的线程安全性。然而，对于涉及可变对象或复杂并发逻辑的场景，synchronizedList的优势微乎其微，因为它无法提供全面的线程安全保障。在这种情况下，开发者通常需要手动使用synchronized块、ReentrantLock或其他并发工具来精细地控制对共享资源的访问，或者考虑使用专门的并发集合类，如CopyOnWriteArrayList（虽然它有其自身的性能开销，尤其是在写操作频繁时）。
总结
在Java中处理ArrayList的迭代与修改，关键在于理解ConcurrentModificationException的触发机制和不同操作的性能特点：
移除元素： 优先使用Collection.removeIf()实现高效的线性时间复杂度移除。如果需要更精细的控制，使用Iterator.remove()，但要注意其在中间位置移除时的潜在性能问题（平方级复杂度）。添加元素： 在迭代过程中添加元素，可使用ListIterator.add()，但同样需警惕其在中间位置添加时的性能开销。对于大量添加，构建新列表是更优的选择。修改元素： 修改ArrayList中元素对象的内部状态是安全的，不会引发ConcurrentModificationException。但请务必注意其线程安全问题，对于可变对象，必须在所有访问和修改点上实施同步。synchronizedList： 它仅保证列表结构操作的线程安全，不保护迭代操作，也不保护列表中可变元素的状态。对于复杂的并发场景，通常需要更细粒度的手动同步控制。
选择合适的策略取决于具体的业务需求、性能要求以及对线程安全性的严格程度。
以上就是Java ArrayList迭代操作中的并发修改异常处理与性能优化的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/962712.html
微信扫一扫 
支付宝扫一扫 
