Java 循环里怎么删除元素才安全

首先

在 Java 中，当你在循环中遍历集合时，直接删除元素可能会引发 ConcurrentModificationException。为了安全地删除元素，推荐使用 Iterator 来进行删除操作。

以下是使用 Iterator 删除元素的常见模式：

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

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        // 使用 Iterator 安全删除元素
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer value = iterator.next();
            if (value % 2 == 0) { // 删除偶数元素
                iterator.remove();
            }
        }

        System.out.println(list); // 输出: [1, 3]
    }
}

关键点：

1. 使用 Iterator 的 remove() 方法删除元素，而不是直接使用 List 的 remove() 方法。
2. 在 for-each 循环中无法使用 Iterator.remove()，必须显式地使用 Iterator 进行遍历和删除操作。

多线程

在多线程环境中，直接操作 List（例如 ArrayList）进行元素删除是线程不安全的，可能会导致并发修改异常（ConcurrentModificationException）或者数据不一致的问题。要在多线程下安全地删除 List 中的元素，以下是几种常见的解决方案：

1. 使用 Collections.synchronizedList 包装 List

Collections.synchronizedList 可以将一个非线程安全的 List 包装成线程安全的 List，所有的操作都会在内部加锁。这样你可以在多线程中安全地操作这个 List，包括删除元素。

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

List<String> list = Collections.synchronizedList(new ArrayList<>());

// 在多线程中使用 synchronizedList 时，遍历时要手动同步：
synchronized (list) {
    list.remove("element");
}

注意：

• 如果要在多线程中对 List 进行迭代时，必须在迭代时手动加锁（使用 synchronized 关键字）以确保线程安全。

2. 使用 CopyOnWriteArrayList 【建议】

CopyOnWriteArrayList 是一种线程安全的 List，它在修改（例如删除）元素时，会复制一个新的底层数组。这意味着读操作不会加锁，写操作则需要复制底层数组。

import java.util.concurrent.CopyOnWriteArrayList;

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("a");
list.add("b");

// 删除元素
list.remove("a");

优点：

• 读操作不需要加锁，可以在多线程环境中高效读取。
• 写操作（增、删、改）时，底层数组会复制，因此是线程安全的。

缺点：

• 由于每次写操作都需要复制数组，写操作的性能较低，适用于读多写少的场景。

3. 使用 synchronized 块手动加锁 [不推荐]

你可以使用 synchronized 关键字来手动控制 List 在多线程环境下的并发操作。通过手动加锁，你可以保证在删除元素时，其他线程不会同时操作这个 List。

List<String> list = new ArrayList<>();

// 加锁删除元素
synchronized (list) {
    list.remove("element");
}

优点：

• 简单直接，可以保证 List 在删除操作时的线程安全。

缺点：

• 需要手动管理锁，容易出现死锁等问题，且锁粒度较大，可能影响性能。

4. 使用并发集合：ConcurrentLinkedQueue

如果你不一定需要使用 List，而更关心元素的顺序和删除操作的线程安全性，ConcurrentLinkedQueue 是一个高效的并发队列，它是线程安全的，并且对删除操作提供了良好的支持。

import java.util.concurrent.ConcurrentLinkedQueue;

ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
queue.add("a");
queue.add("b");

// 删除元素
queue.remove("a");

优点：

• 在高并发环境下有较好的性能表现。
• 是无锁的线程安全实现，适合高频率并发操作。

缺点：

• 并不是 List 类型，它是一个队列，不支持随机访问。

5. 使用 Stream 和 removeIf 结合并发容器

如果需要根据某些条件来删除 List 中的元素，你可以使用 removeIf 方法，配合线程安全的集合（如 CopyOnWriteArrayList）。

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("a");
list.add("b");
list.add("c");

// 删除满足条件的元素
list.removeIf(s -> s.equals("a"));

Java 8+ 的 Stream API 方案：

你也可以使用 Stream API 来过滤出你需要的元素，间接实现删除效果：

list = list.stream()
           .filter(value -> value % 2 != 0) // 保留奇数元素
           .collect(Collectors.toList());

System.out.println(list); // 输出: [1, 3]

这种方法不会在遍历中直接删除元素，而是创建一个新的过滤后的集合。