java中Vector的详细说明

1. Vector 是什么？

Vector是 Java 早期版本（从 JDK 1.0 开始）就存在的一个动态数组实现。它位于 java.util包中，是 Java 集合框架（Java Collections Framework, JCF）的一部分。

​本质​：一个可以根据需要自动增长和缩小的对象数组。

​特点​：

• ​有序（Ordered）​​：元素按照插入的顺序存放，可以通过整数索引（从 0 开始）精确地访问每个元素。
• ​可重复​：允许包含重复的元素。
• ​线程安全（Synchronized）​​：这是 Vector最显著的特点之一。其绝大多数公共方法（如 add, get, remove）都使用了 synchronized关键字修饰，保证了在多线程环境下，同一时间只有一个线程能对 Vector 实例进行修改或读取，从而避免了数据的不一致性。

2. 核心特性详解

a) 动态扩容

这是 Vector和原始数组最根本的区别。你无需在创建时指定最终的大小，它会自动管理容量。

• ​初始容量（Initial Capacity）​​：创建 Vector时内部的数组大小。默认是 ​10。
• ​扩容增量（Capacity Increment）​​：可以指定一个增量值。当需要扩容时，新的容量将是 旧容量 + 增量值。如果创建时未指定增量（或指定为 0），则默认策略是扩容为原来的 2 倍​（newCapacity = oldCapacity * 2）。
• ​扩容时机​：当尝试添加一个新元素（例如 add(e)）并且当前元素数量已经等于内部数组的长度时，就会触发扩容操作。

​示例：​​

Vector<String> vector = new Vector<>(); // 初始容量=10, 增量=0(默认2倍扩容)
for (int i = 0; i < 11; i++) {
    vector.add("Element " + i); // 添加第11个元素时，容量从10扩到20
}

b) 线程安全

正如之前提到的，Vector的方法大多是同步的。这意味着它在多线程环境下是安全的，你可以多个线程同时操作一个 Vector而不会破坏其内部状态（如不会造成数据覆盖）。

​示例代码片段（查看源码）：​​

// Vector 的 add 方法源码大致长这样：
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1); // 检查并扩容
    elementData[elementCount++] = e;
    return true;
}
 
// get 方法也是同步的
public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    return elementData(index);
}

3. 优缺点分析

优点：

1. ​线程安全​：最大的优点，在不需要额外代码的情况下，即可用于多线程场景。
2. ​使用简单​：作为动态数组，其 API 直观易用，避免了原始数组的固定大小限制。

缺点：

1. ​性能开销​：​这是最关键的缺点。同步（synchronized）带来了巨大的性能代价。每次方法调用都需要获取和释放锁，这在单线程环境下是完全不必要的开销，会导致程序变慢。
2. ​过时的设计​：在 Java 1.2 引入更现代的集合框架（如 ArrayList, HashMap）之后，Vector虽然被保留了，但通常被认为是一种“遗留类”（Legacy Class）。它的方法名（如 addElement, elementAt）也没有遵循新的集合接口约定（如 add, get），尽管为了兼容它也实现了这些新方法。
3. ​不如现代的并发集合​：即使在需要线程安全的场景下，Java 5 引入的 java.util.concurrent包中的集合类（如 CopyOnWriteArrayList, ConcurrentHashMap）通常提供了更优的性能和更精细的锁策略（如读写锁、写时复制）。

4. Vector vs ArrayList

这是最常被问到的问题。ArrayList是 Vector的非同步现代替代品。

5. 如何使用 Vector？

尽管不推荐在新项目中使用，但了解其 API 仍有必要。

​创建 Vector：​​

// 1. 默认构造：容量10，扩容时容量翻倍
Vector<String> vec1 = new Vector<>();
 
// 2. 指定初始容量
Vector<String> vec2 = new Vector<>(100);
 
// 3. 指定初始容量和扩容增量
Vector<String> vec3 = new Vector<>(100, 10); // 每次扩容增加10
 
// 4. 通过其他集合创建
List<String> list = Arrays.asList("A", "B", "C");
Vector<String> vec4 = new Vector<>(list);

​基本操作：​​

Vector<Integer> vector = new Vector<>();
 
// 添加元素
vector.add(10);
vector.add(20);
vector.add(1, 15); // 在索引1处插入
 
// 获取元素
int element = vector.get(0); // 10
 
// 修改元素
vector.set(0, 100); // 将索引0改为100
 
// 删除元素
vector.remove(0); // 删除索引0的元素
vector.remove(Integer.valueOf(20)); // 删除值为20的元素
 
// 大小和容量
int size = vector.size(); // 元素数量
int capacity = vector.capacity(); // 当前底层数组的容量
 
// 遍历 (推荐方式)
for (Integer num : vector) {
    System.out.println(num);
}
 
// 枚举器 (古老的方式，不推荐)
Enumeration<Integer> enumeration = vector.elements();
while (enumeration.hasMoreElements()) {
    System.out.println(enumeration.nextElement());
}

6. 现代开发中的替代方案和建议

​单线程环境​：

• ​绝对首选 ArrayList。它没有同步开销，性能远超 Vector。

​多线程环境​：

• ​需要同步的 List​：可以使用 Collections.synchronizedList(new ArrayList())来包装一个 ArrayList，这样得到的 List 是同步的。这比直接使用 Vector更灵活，因为你可以在需要同步时再包装，不需要时就用原始的 ArrayList。
• ​高并发读，少写​：考虑使用 CopyOnWriteArrayList。它在写操作时复制整个新数组，读操作无需加锁，性能极高。
• ​需要更复杂的并发操作​：使用 java.util.concurrent包下的其他并发集合类。

​示例：使用 Collections.synchronizedList​

List<String> syncedList = Collections.synchronizedList(new ArrayList<>());
 
// 在迭代时，你必须手动同步！
synchronized(syncedList) {
    Iterator<String> i = syncedList.iterator();
    while (i.hasNext()) {
        System.out.println(i.next());
    }
}

总结

• Vector是一个线程安全的、动态扩容的数组实现。
• 它的同步特性导致性能较差，是其在现代开发中不被推荐的主要原因。
• 在单线程环境中，​总是优先使用 ArrayList。
• 在多线程环境中，优先考虑 Collections.synchronizedList()、CopyOnWriteArrayList或其他 java.util.concurrent包下的并发容器，而不是 Vector。

理解 Vector更多的是为了理解 Java 集合框架的历史和线程安全的概念，而不是为了在新代码中使用它。

到此这篇关于java中Vector的详细说明的文章就介绍到这了,更多相关java Vector内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！