Java 集合：（七） List实现类：Vector

一、Vector 概述

　　1、Vector 是 List 接口的另一个实现类： Vector

　　2、Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。 

　　3、Vector 的内部实现与 ArrayList 类似，也可以理解为一个【可变数组】。

　　　　其继承结构如下：

　　　　

　　4、由于 Vector 目前使用较少，且官方也推荐在无线程安全的需求时使用 ArrayList 代替 Vector，这里仅研究其实现原理。

　　　　stackoverflow 也有相关的讨论：

               https://stackoverflow.com/questions/1386275/why-is-java-vector-and-stack-class-considered-obsolete-or-deprecated

 

二、实现的接口

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

　　　　可以发现，Vector 实现的接口同 ArrayList，作用也是一致的。

三、成员变量

    /**
     * The array buffer into which the components of the vector are
     * stored. The capacity of the vector is the length of this array buffer,
     * and is at least large enough to contain all the vector's elements.
     *
     * <p>Any array elements following the last element in the Vector are null.
     *
     * @serial
     */
    protected Object[] elementData;  //存储数据的数组

    /**
     * The number of valid components in this {@code Vector} object.
     * Components {@code elementData[0]} through
     * {@code elementData[elementCount-1]} are the actual items.
     *
     * @serial
     */
    protected int elementCount;     //有效元素的个数

    /**
     * The amount by which the capacity of the vector is automatically
     * incremented when its size becomes greater than its capacity.  If
     * the capacity increment is less than or equal to zero, the capacity
     * of the vector is doubled each time it needs to grow.
     *
     * @serial
     */
    protected int capacityIncrement;   //容量增长因子

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -2767605614048989439L;
    
        /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

四、构造器

　　Vector 对外提供四个构造器（内部可以认为是两个）

　　1、方式一：

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

　　　　与 ArrayList 类似，Vector 内部也维护了一个 Object 类型的数组（elementData）来存储元素（默认初始容量也是10）。

　　　　不同的是：Vector 比 ArrayList 的构造器多了一个参数 capacityIncrement，该变量也导致了二者的扩容方式略有不同。

　　2、方式二：入参为集合的构造器

    public Vector(Collection<? extends E> c) {
        Object[] a = c.toArray();
        elementCount = a.length;
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, elementCount, Object[].class);
        }
    }

五、Vector 扩容原理分析

　　1、从构造函数分析

　　　　（1）从上面构造器可以发现以无参数构造方法创建 Vector 时，实际上初始化赋值的是一个容量为10的数组，扩容因子是0。

　　　　（2）还可以指定容量，就会创建一个容量为指定的数组，此时的数组扩容因子是 0。

　　　　（3）也可以同时指定容量和扩容因子，会创建一个指定容量的数组，扩容因子为设置的值。

　　　　

　　2、一步一步分析 Vector 扩容机制

　　　　这里以无参构造函数创建的 ArrayList 为例分析

　　　　（1）先来看 add 方法（addAll()方法类似）

    /**
     * 将指定的元素追加到此列表的末尾。
     */
    public synchronized boolean add(E e) {
        //添加元素之前，先调用ensureCapacityHelper方法
        modCount++;
        ensureCapacityHelper(elementCount + 1);   //确保内部容量
        //这里看到ArrayList添加元素的实质就相当于为数组赋值
        elementData[elementCount++] = e;
        return true;
    }

 　　　　　　可以看到，在 add() 方法执行时，会首先执行  ensureCapacityHelper 方法

 　　　　　　注意这里的关键字 synchronized。观察可以发现：Vector 内部许多方法都使用了该关键字，这也是 Vector 实现线程安全的方式，简单粗暴！

　　　　（2）查看 ensureCapacityHelper() 方法

　　　　　　该方法是非同步的，因为 Vector 内部调用该方法的地方都使用了 synchronized 关键字进行同步，这里不再额外使用

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        //判断是否需要扩容，如果所需容量大于目前数组长度，则进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

　　　　（3）grow()方法

　　　　　　源码：

    /**
     * Vector 扩容的核心方法。
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        // oldCapacity为旧容量，newCapacity为新容量
        int oldCapacity = elementData.length;
        
        //如果指定了扩容因子 capacityIncrement，则在原来容量上扩容
        //如果没有指定扩容因子，则扩容为2倍容量
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
                                         
        //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            
        // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，    
        //如果minCapacity大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为Integer.MAX_VALUE - 8。
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

 　　　　 从这里可以看出，Vector 与 ArrayList 的扩容方式基本一致，只是新容量的计算方式有所不同，这里分析下其新容量大小：

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

　　　　Vector 计算扩容后的新容量时，根据 capacityIncrement 的值可以分为两种情况：

　　　　1. capacityIncrement > 0：新容量 = 旧容量 + capacityIncrement；

　　　　2. capacityIncrement <= 0：新容量 = 旧容量 * 2。

 

　　　　（4）hugeCapacity()方法（巨大的容量）

　　　　　　从上面 grow() 方法源码我们知道： 如果新容量大于 MAX_ARRAY_SIZE，进入(执行) hugeCapacity() 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，如果 minCapacity 大于最大容量，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 Integer.MAX_VALUE - 8。

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

　　3、

　　4、

　　5、

六、常用方法

　　Vector 与 ArrayList 常用方法几乎类似，只是在方面上面添加了 synchronized 关键字来保证同步，因此性能比较差。

　　在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。

七、线程安全性

　　Vector 是线程安全的，它实现线程安全的方式也很简单粗暴：直接在方法上使用 synchronized 关键字进行同步。

八、总结

　　1、与 ArrayList 类似，Vector 也可以认为是【可变数组】；

　　2、扩容原理与 ArrayList 基本一致，只是新容量计算方式略有不同；指定增长容量时，新容量为 旧容量 + 增长容量；否则扩容为旧容量的 两倍。

　　3、线程安全的，实现方式简单（synchronized）

九、

十、