java源码分析---Vector类（JDK14）

更多源码分析，请点击

Vector

Vector 和 ArrayList 原理实现差不多，但是 Vector 是 线程安全 的，在效率上没有 ArrayList 高，因为为保证线程安全，使用 synchronized 关键字修饰方法。

Vector 底层采用 Object 数组来保存数据，所以如果要保存基本类型需要使用他们的包装类。

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    protected Object[] elementData;
    protected int elementCount;
    protected int capacityIncrement;
} 

elementData 用于保存列表中元素的 Object 数组。

elementCount 用来保存当前列表中元素的数量。

capacityIncrement 如果该值大于零时，数组扩容时增加的容量为该值。 如果该值小于或等于零，则数组扩容时扩容为当前数组长度的二倍。

Vector(int, int)

构造函数 ，创建一个 Vector 对象，初始化容量为 initialCapacity ，初始化容量增量为 capacityIncrement 。

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

Vector(initialCapacity)

构造函数 ，创建一个 Vector 对象，初始化容量为 initialCapacity ，初始化容量增量为 0 。

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

Vector()

构造函数 ，创建一个 Vector 对象，初始化容量为 10 ，初始化容量增量为 0 。

public Vector() {
    this(10);
}

Vector(Collection<? extends E>)

创建一个 Vector 对象，初始化内容为集合 c 中的元素。

• 将数组 a 的长度赋给 elementCount ，集合 c 转换为数组 a，如果集合 c 是 ArrayList 对象，则将数组 a 直接赋给 elementData。
• 如果集合 c 不是 ArrayList 对象，则将数组 a 拷贝一份赋值给 elementData。

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

copyInto(Object[])

将当前列表中的元素拷贝到指定数组 anArray 中，调用 System.arraycopy() 方法实现。

public synchronized void copyInto(Object[] anArray) {
    System.arraycopy(elementData, 0, anArray, 0, elementCount);
}

trimToSize()

将当前列表的容量调整为列表的实际大小。

• modCount 是记录列表结构被修改的次数，定义在父类 AbstractList 中。
• 将列表按照实际存储元素的数量拷贝一份返回。

public synchronized void trimToSize() {
    modCount++;
    int oldCapacity = elementData.length;
    if (elementCount < oldCapacity) {
        elementData = Arrays.copyOf(elementData, elementCount);
    }
}

ensureCapacity(int)

确保数组中最少可以存放 minCapacity 个元素。

如果 minCapacity 大于当前列表长度，需要调用 grow 方法进行扩容。

public synchronized void ensureCapacity(int minCapacity) {
    if (minCapacity > 0) {
        modCount++;
        if (minCapacity > elementData.length)
            grow(minCapacity);
    }
}

grow(int)

对列表进行扩容，确保列表中最少可以存放 minCapacity 个元素。

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = ArraysSupport.newLength(oldCapacity,
            minCapacity - oldCapacity, /* minimum growth */
            capacityIncrement > 0 ? capacityIncrement : oldCapacity
                                       /* preferred growth */);
    return elementData = Arrays.copyOf(elementData, newCapacity);
}

• 如果 capacityIncrement 的值大于零，则数组增加的长度为 capacityIncrement 的值，否则，数组长度增加为原来的二倍。
• 如果此时数组的长度仍然小于 minCapacity ，直接将数组的长度增加至 minCapacity 。
• 将数组中原来的元素拷贝到新的数组中。

grow()

对当前列表进行扩容，扩容后的最小长度为 elementCount+1 ，调用 grow(int) 方法实现。

private Object[] grow() {
    return grow(elementCount + 1);
}

setSize(int)

将当前列表中数组的元素个数设置为 newSize 。

• 如果当前数组长度小于 newSize ，先对数组进行扩容
• 将索引 newSize 及之后的元素都置为 null 。

public synchronized void setSize(int newSize) {
    modCount++;
    if (newSize > elementData.length)
        grow(newSize);
    final Object[] es = elementData;
    for (int to = elementCount, i = newSize; i < to; i++)
        es[i] = null;
    elementCount = newSize;
}

其他方法和 ArrayList 中的方法差不多，只是在 Vector 中增加了 sychronized 关键字修饰。

更多源码分析，请点击