Vector与ArrayList的最大的不同是它是线程安全的。

定义

Vector定义:

public class Vector<E> extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Vector:说明它支持泛型
extends AbstractList:继承了AbstractList
implements List:实现了List
RandomAccess:表明其支持快速(通常是固定时间)随机访问。此接口的主要目的是允许一般的算法更改其行为,从而在将其应用到随机或连续访问列表时提供良好的性能。
Cloneable:表明其可以调用clone()方法来返回实例的field-for-field拷贝。
java.io.Serializable:表明该类是可以序列化的。

构造方法

Vector提供了四种构造方法。

  1. 构造一个指定容量为capacity、自增容量为capacityIncrement的空vector。
  2. 构造一个指定容量为initialCapacity、自增容量为0的空vector。
  3. 构造一个指定容量为10、自增容量为0的空vector。
  4. 使用指定的Collection构造vector。

核心方法

Vector有以下核心方法。

  1. copyInto(Object[] anArray)
    将vector中的所有元素拷贝到指定的数组anArray中。

  2. trimToSize()
    将底层数组的容量调整为当前vector实际元素的个数,来释放空间。

  3. ensureCapacity(int minCapacity)
    该方法的实现和ArrayList中大致相同。不同的是在第一次扩容时,vector的逻辑是:
    newCapacity = oldCapacity + ((capacityIncrement > 0) ?
    capacityIncrement : oldCapacity);
    即如果capacityIncrement>0,就加capacityIncrement,如果不是就增加一倍。
    而ArrayList的逻辑是:
    newCapacity = oldCapacity + (oldCapacity >> 1);
    即增加现有的一半。

源码分析

  • Vector底层是数组。
  • 有序。Vector底层是数组,数组是有序的。
  • 可重复。数组是可重复的。
  • 随机访问效率高,增删效率低。通过索引可以很快的查找到对应元素,而增删元素,许多元素的位置都要改变。
  • 线程安全。很多方法都是synchronized的。
  1. 同步
    它的实现与ArrayList类似,但是使用了synchronized进行同步。
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}
public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    return elementData(index);
}

2. 扩容
Vector 的构造函数可以传入 capacityIncrement 参数,它的作用是在扩容时使容量 capacity 增长 capacityIncrement。如果这个参数的值小于等于 0,扩容时每次都令 capacity 为原来的两倍。
```java
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

···

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

调用没有 capacityIncrement 的构造函数时,capacityIncrement 值被设置为 0,也就是说默认情况下 Vector 每次扩容时容量都会翻倍。

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}
public Vector() {
    this(10);
}
  1. 与ArrayList的比较
  • Vector 是同步的,因此开销就比 ArrayList 要大,访问速度更慢。最好使用 ArrayList 而不是 Vector,因为同步操作完全可以由程序员自己来控制;
  • Vector 每次扩容请求其大小的 2 倍(也可以通过构造函数设置增长的容量),而 ArrayList 是 1.5 倍。
  1. 替代方案
    可以使用 Collections.synchronizedList(); 得到一个线程安全的 ArrayList。
List<String> list = new ArrayList<>();
List<String> synList = Collections.synchronizedList(list);

也可以使用 concurrent 并发包下的 CopyOnWriteArrayList 类。

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

CopyOnWriteArrayList

  1. 读写分离
    写操作在一个复制的数组上进行,读操作还是在原始数组中进行,读写分离,互不影响。
    写操作需要加锁,防止并发写入时导致写入数据丢失。
    写操作结束之后需要把原始数组指向新的复制数组。
public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}
final void setArray(Object[] a) {
    array = a;
}
···
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
    return (E) a[index];
}
  1. 适用场景
    CopyOnWriteArrayList 在写操作的同时允许读操作,大大提高了读操作的性能,因此很适合读多写少的应用场景。
    但是 CopyOnWriteArrayList 有其缺陷:
  • 内存占用:在写操作时需要复制一个新的数组,使得内存占用为原来的两倍左右;
  • 数据不一致:读操作不能读取实时性的数据,因为部分写操作的数据还未同步到读数组中。
    所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。