Java集合类学习--Vector

概述

Vector 的内部实现与 ArrayList 类似，也可以理解为一个「可变数组」。由于 Vector 目前使用较少，且官方也推荐在无线程安全的需求时使用 ArrayList 代替 Vector，这里仅研究其实现原理。其继承结构如下（省略部分接口）：

源码分析

构造器
Vector 对外提供四个构造器：

protected Object[] elementData;

protected int capacityIncrement;

// 无参构造器
public Vector() {
    this(10);
}

// 指定容量的构造器
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

// 指定初始容量和容量增长因子的构造器
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

public Vector(Collection<? extends E> c) {
    elementData = c.toArray();
    elementCount = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

与 ArrayList 类似，Vector 内部也维护了一个 Object 类型的数组（elementData）来存储元素（默认初始容量也是 10）。不同的是：Vector 比 ArrayList 的构造器多了一个参数 capacityIncrement，该变量也导致了二者的扩容方式略有不同。

add(E e)方法

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

可以看到关键字 synchronized。观察可以发现：Vector 内部许多方法都使用了该关键字，这也是 Vector 实现线程安全的方式，非常简单粗暴！
扩容机制基本上和ArrayList是一致的，只是容量计算方式不同：

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

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);
    }

int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);

由上面一段代码可以看出Vector 计算扩容后的新容量时，根据 capacityIncrement 的值可以分为两种情况：
capacityIncrement > 0：新容量 = 旧容量 + capacityIncrement；
capacityIncrement <= 0：新容量 = 旧容量 * 2。

其他方法基本上和ArrayList一致，可以忽略，学习参考ArrayList。

总结
1、与 ArrayList 类似，Vector 也可以认为是「可变数组」；
2、扩容原理与 ArrayList 基本一致，只是新容量计算方式略有不同：指定增长容量时，新容量为旧容量 + 增长容量；否则扩容为旧容量的 2 倍；
3、由于是线程安全的，实现方式简单（synchronized），由于效率问题，使用较少。