Java Vector删除元素会报错吗？-杰瑞科技汇

下面我将详细介绍几种删除元素的方法，并重点讲解最容易出错的 并发修改异常。

`Vector` 的主要删除方法

Vector 提供了以下几个核心的删除方法：

remove(int index): 删除指定索引位置上的元素。
remove(Object o): 删除第一个遇到的与 o 相等（equals() 方法判断）的元素。
removeAllElements(): 清空 Vector,移除所有元素。
removeElement(Object obj): 与 remove(Object o) 功能相同，是 Vector 特有的命名方法。
removeElementAt(int index): 与 remove(int index) 功能相同，是 Vector 特有的命名方法。
clear(): 清空 Vector，功能与 removeAllElements() 相同，是 Collection 接口中的标准方法,推荐使用。

根据索引删除 `remove(int index)`

这是最直接的删除方式,通过元素的索引来删除。

import java.util.Vector;
public class VectorRemoveExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("Apple");
        vector.add("Banana");
        vector.add("Orange");
        vector.add("Mango");
        System.out.println("删除前: " + vector); // [Apple, Banana, Orange, Mango]
        // 删除索引为 2 的元素 ("Orange")
        String removedFruit = vector.remove(2);
        System.out.println("被删除的元素: " + removedFruit); // Orange
        System.out.println("删除后: " + vector); // [Apple, Banana, Mango]
    }
}

注意：删除一个元素后，Vector 中所有后续元素的索引都会向前移动一位，如果你在一个循环中连续删除元素,需要小心索引的变化。

根据对象内容删除 `remove(Object o)`

如果你想删除一个具体的值，可以使用这个方法,它会删除第一个匹配的元素。

import java.util.Vector;
public class VectorRemoveObjectExample {
    public static void main(String[] args) {
        Vector<Integer> numbers = new Vector<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(20);
        numbers.add(40);
        System.out.println("删除前: " + numbers); // [10, 20, 30, 20, 40]
        // 删除第一个值为 20 的元素
        boolean removed = numbers.remove(Integer.valueOf(20)); // 注意使用 Integer.valueOf
        System.out.println("是否删除成功: " + removed); // true
        System.out.println("删除后: " + numbers); // [10, 30, 20, 40]
    }
}

重要提示：

numbers.remove(20) 和 numbers.remove(Integer.valueOf(20)) 是不同的！
numbers.remove(20) 会尝试删除索引为 20 的元素，Vector 的大小小于 21，会抛出 ArrayIndexOutOfBoundsException。
numbers.remove(Integer.valueOf(20)) 才是删除值为 20 的对象，这是 remove(Object o) 方法的正确用法。

⚠️ 重点：在循环中删除元素（避免 `ConcurrentModificationException`）

这是 Vector 删除操作中最容易出错的地方，如果你使用 for 循环或 while 循环，并用 size() 作为条件，同时循环体内调用 remove() 方法，很可能会导致 ConcurrentModificationException（并发修改异常）。

错误示范（会导致异常）

import java.util.Vector;
public class WrongRemoveExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("A");
        vector.add("B");
        vector.add("C");
        vector.add("D");
        vector.add("E");
        // 错误的删除方式
        for (int i = 0; i < vector.size(); i++) {
            if (vector.get(i).equals("C")) {
                vector.remove(i); // 删除后，元素前移，但 i 已经自增了，会跳过下一个元素
            }
        }
        // System.out.println("这行代码可能不会执行，因为上面的循环在特定情况下会出错");
    }
}

上面的代码在某些情况下（比如删除中间元素）逻辑是错误的，因为 i 会自增，导致跳过被前移的元素，更严重的是，如果你使用增强 for 循环，几乎一定会抛出 ConcurrentModificationException。

// 绝对错误的示范 - 增强for循环
for (String item : vector) {
    if (item.equals("B")) {
        vector.remove(item); // 必然抛出 ConcurrentModificationException
    }
}

正确的删除方式

有三种安全且推荐的方式在循环中删除元素：

方式 1：使用 `Iterator` (最经典、最通用)

Iterator 提供了 remove() 方法，它会在上次调用 next() 之后删除元素，并且能正确处理底层集合的修改,不会抛出异常。

import java.util.Iterator;
import java.util.Vector;
public class IteratorRemoveExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("A");
        vector.add("B");
        vector.add("C");
        vector.add("D");
        vector.add("E");
        System.out.println("删除前: " + vector);
        Iterator<String> iterator = vector.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("C")) {
                iterator.remove(); // 使用 Iterator 的 remove 方法，非常安全
            }
        }
        System.out.println("删除后: " + vector); // [A, B, D, E]
    }
}

方式 2：使用 `for` 循环倒序删除

如果你不想使用 Iterator，可以倒序遍历，这样删除元素时,不会影响前面未遍历到的元素的索引。

import java.util.Vector;
public class ReverseRemoveExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("A");
        vector.add("B");
        vector.add("C");
        vector.add("D");
        vector.add("E");
        System.out.println("删除前: " + vector);
        // 从后往前遍历
        for (int i = vector.size() - 1; i >= 0; i--) {
            if (vector.get(i).equals("C")) {
                vector.remove(i);
            }
        }
        System.out.println("删除后: " + vector); // [A, B, D, E]
    }
}

方式 3：使用 Java 8+ 的 Stream API (现代、简洁)

如果你使用的是 Java 8 或更高版本，Stream API 是最优雅的解决方案，它通过创建一个新的集合来过滤掉不需要的元素,避免了在原集合上修改的问题。

import java.util.Vector;
import java.util.stream.Collectors;
public class StreamRemoveExample {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        vector.add("A");
        vector.add("B");
        vector.add("C");
        vector.add("D");
        vector.add("E");
        System.out.println("删除前: " + vector);
        // 使用 Stream 过滤元素，然后收集到一个新的 Vector 中
        Vector<String> newVector = vector.stream()
                                         .filter(item -> !item.equals("C"))
                                         .collect(Collectors.toCollection(Vector::new));
        // 或者直接替换原引用
        vector = vector.stream()
                       .filter(item -> !item.equals("C"))
                       .collect(Collectors.toCollection(Vector::new));
        System.out.println("删除后: " + vector); // [A, B, D, E]
    }
}

总结与最佳实践

场景	推荐方法	优点	缺点
删除单个指定索引的元素	`vector.remove(index)`	简单直接	-
删除单个指定值的元素	`vector.remove(Object o)`	语义清晰	只删除第一个匹配项
清空整个 `Vector`	`vector.clear()`	代码清晰，是标准API	-
在循环中删除一个或多个元素	`Iterator`	最安全、最通用，不会抛出异常	代码稍显冗长
在循环中删除（倒序）	`for (int i = size() - 1; i >= 0; i--)`	效率高，逻辑清晰	需要手动管理索引
在循环中删除（现代Java）	`Stream.filter()`	代码简洁，可读性高，无并发修改风险	会创建新集合，对性能有轻微影响

核心建议：

永远不要在增强 for 循环 (for-each) 中调用 collection.remove()。
优先使用 Iterator 的 remove() 方法 来处理循环中删除元素的场景,这是最稳妥的方案。
如果你的项目使用的是 Java 8+，Stream API 是非常优秀的选择,尤其是在需要复杂过滤条件时。
Vector 是线程安全的，但它的同步开销较大，在不需要线程安全的单线程环境中，优先考虑使用 ArrayList。

Java Vector删除元素会报错吗？