Java ArrayList在迭代过程中进行增删改操作及并发安全指南

本文深入探讨了在java中对`arraylist`进行迭代时，如何安全高效地执行添加、删除和修改操作，同时避免`concurrentmodificationexception`。文章比较了不同迭代方式（增强for循环、`iterator`、`listiterator`）的适用场景和性能考量，特别强调了`iterator.remove()`和`removeif()`方法的重要性。此外，还详细分析了`arraylist`的线程安全性问题，以及`synchronizedlist`在保护列表结构和其中可变对象方面的局局限性，提供了确保并发安全的实践建议。

理解ConcurrentModificationException与迭代方式

在Java中，当一个线程正在迭代一个集合时，另一个线程（或同一个线程通过非迭代器方法）修改了该集合的结构（例如添加、删除元素），就会抛出ConcurrentModificationException。这是Java集合框架的“快速失败”（fail-fast）机制，旨在尽早发现并发修改问题。

1. 修改元素内容（非结构性修改）

对于ArrayList中元素的内容修改，无论是使用增强for循环（foreach）还是显式Iterator，其性能和行为基本一致。这是因为ArrayList存储的是对象的引用，修改对象内部状态并不会改变ArrayList的结构。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

class Item {
    private String name;
    private int value;

    public Item(String name, int value) {
        this.name = name;
        this.value = value;
    }

    public void updateValue(int newValue) {
        this.value = newValue;
        System.out.println("Updated item: " + name + ", new value: " + value);
    }

    @Override
    public String toString() {
        return "Item{name='" + name + "', value=" + value + '}';
    }
}

public class ArrayListModificationDemo {

    public static void main(String[] args) {
        List items = new ArrayList<>();
        items.add(new Item("Apple", 10));
        items.add(new Item("Banana", 20));
        items.add(new Item("Cherry", 30));

        System.out.println("--- Original List ---");
        items.forEach(System.out::println);

        // 使用增强for循环修改元素内容
        System.out.println("\n--- Modifying content with enhanced for loop ---");
        for (Item item : items) {
            item.updateValue(item.value + 1);
        }
        items.forEach(System.out::println);

        // 使用Iterator修改元素内容
        System.out.println("\n--- Modifying content with Iterator ---");
        Iterator itemIterator = items.iterator();
        while (itemIterator.hasNext()) {
            Item item = itemIterator.next();
            item.updateValue(item.value + 1);
        }
        items.forEach(System.out::println);
    }
}

这两种方式在编译后生成的字节码非常相似，因此在性能上没有显著差异。关键在于，这种操作仅修改了Item对象本身的状态，而ArrayList中存储的引用并未改变，也未增删元素。

安全地进行结构性修改（添加与删除）

当需要在迭代过程中添加或删除ArrayList中的元素时，必须特别小心，以避免ConcurrentModificationException和潜在的逻辑错误。

立即学习“Java免费学习笔记（深入）”；

1. 删除元素

在迭代过程中删除元素，直接使用ArrayList.remove()方法会导致ConcurrentModificationException。正确的做法是使用Iterator的remove()方法。

• 使用Iterator.remove()：Iterator的remove()方法是唯一在迭代过程中安全删除元素的机制。它会在删除元素后正确更新迭代器的内部状态。

  List items = new ArrayList<>();
  items.add(new Item("Apple", 10));
  items.add(new Item("Banana", 20));
  items.add(new Item("Cherry", 30));
  items.add(new Item("Date", 40));
  
  System.out.println("\n--- Original List for Removal ---");
  items.forEach(System.out::println);
  
  System.out.println("\n--- Removing 'Banana' with Iterator.remove() ---");
  Iterator iterator = items.iterator();
  while (iterator.hasNext()) {
      Item item = iterator.next();
      if (item.toString().contains("Banana")) { // 假设通过名称判断
          iterator.remove(); // 安全删除
          System.out.println("Removed: " + item);
      }
  }
  System.out.println("List after removal: " + items);

• 使用List.removeIf()（推荐）： 对于批量删除，Java 8引入的removeIf()方法是更优的选择。它利用内部迭代器，并在内部优化了元素的移动，从而实现了线性时间复杂度，避免了在循环中频繁调用remove()可能导致的二次时间复杂度问题。

  List itemsForRemoveIf = new ArrayList<>();
  itemsForRemoveIf.add(new Item("Apple", 10));
  itemsForRemoveIf.add(new Item("Banana", 20));
  itemsForRemoveIf.add(new Item("Cherry", 30));
  itemsForRemoveIf.add(new Item("Date", 40));
  
  System.out.println("\n--- Original List for removeIf ---");
  itemsForRemoveIf.forEach(System.out::println);
  
  System.out.println("\n--- Removing items with value > 20 using removeIf() ---");
  itemsForRemoveIf.removeIf(item -> {
      boolean shouldRemove = item.toString().contains("Banana") || item.value > 20;
      if (shouldRemove) {
          System.out.println("Removing via removeIf: " + item);
      }
      return shouldRemove;
  });
  System.out.println("List after removeIf: " + itemsForRemoveIf);

• 复制到新列表： 如果需要删除大量元素或在复杂逻辑下删除，可以考虑创建一个新列表，只将需要保留的元素复制过去。这种方法虽然会占用额外内存，但操作简单且时间复杂度为线性。

  List originalList = new ArrayList<>();
  // ... 添加元素
  List newList = new ArrayList<>();
  for (Item item : originalList) {
      if (!shouldRemove(item)) { // 根据条件判断是否保留
          newList.add(item);
      }
  }
  // originalList = newList; // 或者直接操作newList

2. 添加元素

标准的Iterator接口不提供添加元素的方法。如果需要在迭代过程中添加元素，必须使用ListIterator。

• 使用ListIterator.add()：ListIterator是List特有的迭代器，它提供了add()方法，允许在当前迭代位置插入元素。

  List itemsForAdd = new ArrayList<>();
  itemsForAdd.add(new Item("Apple", 10));
  itemsForAdd.add(new Item("Banana", 20));
  
  System.out.println("\n--- Original List for Addition ---");
  itemsForAdd.forEach(System.out::println);
  
  System.out.println("\n--- Adding elements with ListIterator.add() ---");
  ListIterator listIterator = itemsForAdd.listIterator();
  while (listIterator.hasNext()) {
      Item item = listIterator.next();
      if (item.toString().contains("Banana")) {
          listIterator.add(new Item("Orange", 15)); // 在Banana后面添加Orange
          System.out.println("Added 'Orange' after " + item);
      }
  }
  System.out.println("List after addition: " + itemsForAdd);

  需要注意的是，ArrayList的add(index, element)操作，当插入位置不在末尾时，需要将插入点之后的所有元素向后移动一位。这在循环中频繁进行时，同样会导致二次时间复杂度的性能问题。

• 复制到新列表： 与删除类似，如果需要添加大量元素或在复杂逻辑下添加，创建新列表并重新填充可能更高效。

总结结构性修改的性能考量：

• ArrayList的add(index, element)和remove(index)操作，其时间复杂度为O(n-i)，其中n是列表大小，i是操作的索引。这意味着在列表开头或中间进行频繁的增删操作会导致二次时间复杂度。
• removeIf()方法通过内部优化，将多次元素移动合并为一次，实现了线性时间复杂度。
• 对于大量增删操作，考虑构建一个新列表，或使用更适合频繁中间增删的链表结构（如LinkedList）。

线程安全性考量

ArrayList本身是非线程安全的。这意味着在多线程环境中，如果多个线程同时对ArrayList进行结构性修改或读写操作，可能会导致数据不一致、ConcurrentModificationException甚至程序崩溃。

Petalica Paint

用AI为你的画自动上色！

下载

1. synchronized块与Collections.synchronizedList()

• 手动synchronized块： 为了确保线程安全，最基本的方法是使用synchronized关键字保护对ArrayList的所有访问。

  List items = new ArrayList<>();
  // ... 初始化
  
  // 保护迭代
  synchronized (items) {
      for (Item item : items) {
          // ... 读操作
      }
  }
  
  // 保护修改
  synchronized (items) {
      items.add(new Item("Grape", 50));
  }

• Collections.synchronizedList()：Collections.synchronizedList()方法可以返回一个线程安全的List包装器。它会在所有公共方法上添加synchronized关键字。

  List synchronizedItems = Collections.synchronizedList(new ArrayList<>());
  // ... 对synchronizedItems进行操作

  重要提示： 尽管synchronizedList包装了列表的所有结构性操作，但它不保护迭代。根据Java文档，当迭代synchronizedList时，仍然需要手动在迭代器外部进行同步：

  synchronized (synchronizedItems) { // 必须手动同步迭代器
      Iterator it = synchronizedItems.iterator();
      while (it.hasNext()) {
          Item item = it.next();
          // ... 操作 item
      }
  }

2. synchronizedList的局限性与可变对象

synchronizedList的另一个重要局限是，它只保护了列表自身结构的线程安全，而不保护列表中存储的可变对象（如本例中的Item对象）的线程安全。

如果Item对象是可变的，并且在从synchronizedList中取出后，在synchronized块外部被其他线程修改，那么仍然会存在线程安全问题。

// 假设 Item 内部有方法可以修改其状态
Item item = synchronizedItems.get(0); // 从同步列表中获取
// 此时，item 对象本身可能在 synchronized 块外部被另一个线程修改，导致数据不一致
item.updateValue(999); // 如果没有对 item 对象的访问也进行同步，这里就是线程不安全的

为了实现完全的线程安全，所有对共享可变对象的访问（包括列表本身和列表中包含的元素）都必须由相同的同步机制保护。这意味着，如果Item对象是可变的，那么对Item对象内部状态的修改也需要同步。

3. 何时使用CopyOnWriteArrayList

问题中提到了CopyOnWriteArrayList。它是一个线程安全的List实现，通过在每次修改操作时创建一个底层数组的副本来保证线程安全。

• 优点： 在读操作远多于写操作的场景下性能极佳，因为读操作无需加锁，可以直接访问旧数组。迭代器不会抛出ConcurrentModificationException。
• 缺点： 每次修改都会复制整个底层数组，对于大型列表或频繁修改的场景，性能开销和内存消耗会非常大。此外，迭代器看到的是创建时的数据快照，可能无法反映最新的修改。

因此，CopyOnWriteArrayList不适用于大型列表且修改频繁的场景，这与问题中的上下文相符。

4. 总结线程安全策略

• 对于简单的、非并发的列表操作，使用ArrayList即可。
• 在多线程环境中，如果需要对ArrayList进行结构性修改，必须手动进行同步（使用synchronized块或ReentrantLock）。
• Collections.synchronizedList()提供了一种便捷的包装，但不自动同步迭代，且不保护列表中可变对象的内部状态。
• 对于读多写少的场景，且列表规模适中，可以考虑CopyOnWriteArrayList。
• 对于复杂的并发场景，通常需要更细粒度的锁机制、不可变对象或使用java.util.concurrent包中的其他并发集合（如ConcurrentHashMap、ConcurrentLinkedQueue等）。

总结与最佳实践

在Java中处理ArrayList的迭代和修改，尤其是在并发环境下，需要深入理解其工作原理和潜在问题。

1. 元素内容修改： 增强for循环和显式Iterator在修改元素内容（非结构性修改）时性能和行为一致，都是安全的。
2. 元素删除：
   • 单个删除：使用Iterator.remove()是唯一安全的迭代器删除方式。
   • 批量删除：强烈推荐使用List.removeIf()，它提供了线性的时间复杂度，性能更优。
   • 复杂删除：考虑创建新列表并筛选。
3. 元素添加：
   • 迭代时添加：使用ListIterator.add()。
   • 批量添加：如果添加位置随机且数量大，考虑创建新列表。
   • 注意ArrayList在中间位置的增删操作可能导致二次时间复杂度。
4. 线程安全：
   • ArrayList本身非线程安全。
   • Collections.synchronizedList()可以包装列表实现线程安全，但迭代时仍需手动同步，且不保护列表中可变元素的内部状态。
   • 对于可变元素，其内部状态的访问和修改也需要同步。
   • CopyOnWriteArrayList适用于读多写少、列表不大的场景，但对于频繁修改的大型列表不适用。
   • 复杂并发场景应考虑手动同步、不可变对象或java.util.concurrent包中的高级并发集合。

理解这些原则，可以帮助开发者编写出更健壮、高效且线程安全的Java代码。