Java 实例 – 删除集合中指定元素（详细教程）

Java 实例 – 删除集合中指定元素：从入门到精通

在日常开发中，集合（Collection）是 Java 中最常用的数据结构之一。无论是处理用户列表、订单数据，还是临时存储配置信息，我们几乎总会遇到需要“删除某个特定元素”的场景。然而，看似简单的操作背后，却隐藏着不少陷阱。今天我们就来深入剖析“Java 实例 – 删除集合中指定元素”这一经典问题，带你避开常见坑点，写出更健壮、高效的代码。

想象一下，你正在维护一个学生名单系统。某天，一位学生毕业离校，你得从名单中把他移除。这个“移除”动作，看似简单，但在 Java 中却有多种实现方式，每种方式的适用场景和潜在风险都不同。接下来，我们将一步步拆解这些方法，让你真正掌握其中的门道。

集合删除操作的常见误区

在动手写代码之前，先来聊聊一个高频错误：在遍历集合时直接调用 remove() 方法。

我们来看一个典型的反面例子：

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

public class RemoveExample {
    public static void main(String[] args) {
        List<String> students = new ArrayList<>();
        students.add("张三");
        students.add("李四");
        students.add("王五");
        students.add("赵六");

        // ❌ 错误示范：遍历时直接删除
        for (String student : students) {
            if ("李四".equals(student)) {
                students.remove(student); // 抛出 ConcurrentModificationException
            }
        }
    }
}

这段代码运行时会抛出 ConcurrentModificationException 异常。为什么？因为 Java 的集合类为了保证线程安全，在遍历时会记录一个“修改计数器”（modCount）。当你在 for-each 循环中调用 remove() 时，修改计数器被改变，但迭代器并不知道，于是触发异常。

这就像你在数一盒糖果时，有人偷偷拿走一颗，你却不知道——数到一半发现总数对不上，只能停下来检查。Java 的机制就是防止这种“数据不一致”的情况发生。

正确的删除方式一：使用迭代器（Iterator）

最安全、最推荐的方式是使用 Iterator。它内部维护了修改计数器，能感知到集合的变更，并在必要时抛出异常，帮助你及时发现问题。

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

public class SafeRemoveWithIterator {
    public static void main(String[] args) {
        List<String> students = new ArrayList<>();
        students.add("张三");
        students.add("李四");
        students.add("王五");
        students.add("赵六");

        // ✅ 正确做法：使用 Iterator 遍历并删除
        Iterator<String> iterator = students.iterator();
        while (iterator.hasNext()) {
            String student = iterator.next();
            if ("李四".equals(student)) {
                iterator.remove(); // 安全地删除当前元素
            }
        }

        System.out.println("删除后的名单：" + students);
        // 输出：删除后的名单：[张三, 王五, 赵六]
    }
}

关键点说明：

• iterator.remove() 是唯一允许在遍历时安全删除的方法。
• 它只能调用一次，且必须在 next() 之后调用。如果连续调用 remove() 会抛出 IllegalStateException。
• 该方式适用于所有实现了 List 接口的集合，如 ArrayList、LinkedList。

正确的删除方式二：倒序遍历（适用于 List）

如果你坚持使用传统的 for 循环，可以采用“倒序遍历”的技巧。因为删除元素后，后面元素的索引会前移，正序遍历会跳过某些元素。

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

public class ReverseLoopRemove {
    public static void main(String[] args) {
        List<String> students = new ArrayList<>();
        students.add("张三");
        students.add("李四");
        students.add("王五");
        students.add("赵六");

        // ✅ 正确做法：从后往前遍历
        for (int i = students.size() - 1; i >= 0; i--) {
            String student = students.get(i);
            if ("李四".equals(student)) {
                students.remove(i); // 根据索引删除，不会影响前面元素的索引
            }
        }

        System.out.println("删除后的名单：" + students);
        // 输出：删除后的名单：[张三, 王五, 赵六]
    }
}

为什么倒序安全？

• 删除索引为 i 的元素后，只有索引大于 i 的元素受影响。
• 你从后往前遍历，所以前面的索引不会被“跳过”。
• 就像你从一排书架的末尾开始拆书，前面的书位置不会变。

正确的删除方式三：使用 Stream API（Java 8+）

Java 8 引入的 Stream API 让集合操作更加简洁、函数式。删除元素也可以用 filter + collect 的方式完成。

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class StreamRemoveExample {
    public static void main(String[] args) {
        List<String> students = new ArrayList<>();
        students.add("张三");
        students.add("李四");
        students.add("王五");
        students.add("赵六");

        // ✅ 使用 Stream 进行筛选删除
        List<String> filteredStudents = students.stream()
            .filter(student -> !student.equals("李四")) // 保留不是“李四”的
            .collect(Collectors.toList());

        System.out.println("删除后的名单：" + filteredStudents);
        // 输出：删除后的名单：[张三, 王五, 赵六]
    }
}

优点：

• 代码简洁，逻辑清晰。
• 不修改原集合，返回新集合，避免副作用。
• 适合复杂条件判断，如多个条件组合。

注意： Stream 操作不改变原集合，而是生成新集合。如果需要修改原集合，需重新赋值。

不同集合类型下的删除行为对比

不同集合类在删除元素时的行为略有差异，我们通过一张表格来总结：

注：remove(Object) 会调用 equals() 比较元素，确保删除的是“值相等”的对象，而非“引用相同”。

实际应用案例：清理无效订单

假设你有一个订单系统，需要清除状态为“已取消”的订单。以下是完整的实现示例：

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

public class OrderCleanup {
    static class Order {
        private String id;
        private String status;

        public Order(String id, String status) {
            this.id = id;
            this.status = status;
        }

        public String getId() { return id; }
        public String getStatus() { return status; }

        @Override
        public String toString() {
            return "Order{id='" + id + "', status='" + status + "'}";
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Order order = (Order) o;
            return id.equals(order.id);
        }

        @Override
        public int hashCode() {
            return id.hashCode();
        }
    }

    public static void main(String[] args) {
        List<Order> orders = new ArrayList<>();
        orders.add(new Order("001", "已处理"));
        orders.add(new Order("002", "已取消"));
        orders.add(new Order("003", "待支付"));
        orders.add(new Order("004", "已取消"));

        // 使用 Iterator 安全删除
        Iterator<Order> iterator = orders.iterator();
        while (iterator.hasNext()) {
            Order order = iterator.next();
            if ("已取消".equals(order.getStatus())) {
                iterator.remove();
            }
        }

        System.out.println("清理后的订单列表：");
        orders.forEach(System.out::println);
        // 输出：
        // 清理后的订单列表：
        // Order{id='001', status='已处理'}
        // Order{id='003', status='待支付'}
    }
}

这个例子展示了如何在真实业务中安全地删除集合中的指定元素。关键在于：不要在遍历时直接调用 remove()，而要用 Iterator 或倒序索引删除。

总结与建议

通过本文的深入讲解，你应该已经掌握了“Java 实例 – 删除集合中指定元素”的多种正确方法。我们总结一下核心要点：

• 避免在 for-each 循环中直接删除元素，否则会抛出 ConcurrentModificationException。
• 首选 Iterator.remove()，它是安全、可靠的标准做法。
• 倒序遍历适用于 List 类型，避免索引错乱。
• Stream API 适合函数式编程风格，代码更简洁，但会创建新集合。
• 不同集合类型删除性能不同，根据业务场景选择合适类型。

最后提醒一句：编程不是追求“能跑就行”，而是追求“跑得稳、跑得快、跑得优雅”。一个小小的删除操作，也可能成为线上问题的根源。多花一分钟思考删除方式，就能避免未来一小时的排查。

希望今天的分享能让你在处理集合删除时更加从容自信。如果你觉得有用，欢迎转发给还在为“删除报错”发愁的朋友。