集合框架源码分析(jdK1.7)（七） Vector

1.Vector的数据结构

protected Object[] elementData;

//可以看出来Vector的数据结构和ArrayList的数据结构是相同的都是一个数组

2.主要参数

protected Object[] elementData; //一个数组维护Vector的数据结构

protected int elementCount; //元素数量

protected int capacityIncrement; //每次扩容大小

protected transient int modCount = 0;

3.核心构造方法

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]; //创建一个长度为initialCapacity的数组（默认为10）
    this.capacityIncrement = capacityIncrement;
}

capacityIncrement：指示每次扩容的大小，默认是扩大现有容量的1倍

initialCapacity：初始容量(默认的初始化容量为10)

4. add(E e)方法

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1); //扩容方式
    elementData[elementCount++] = e; // 增加在数组尾部
    return true;
}

Vector的方法都使用了关键字sychronized修饰。所以是线程安全的。

5扩容方式

private void ensureCapacityHelper(int minCapacity) {
    // 空间不足进行扩容
    if (minCapacity - elementData.length > 0) //新增加元素的位置和数据长度比较（数组长度默认为10）
        grow(minCapacity);
}

private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;

    //扩容方式如果设置了扩容大小(capacityIncrement > 0)按照扩容大小增加否则增加到原来的2倍
    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);
}

6get(int index)方法

public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    return elementData(index);
}

E elementData(int index) {
return (E) elementData[index];
}

synchronized修饰线程安全的，按照数组方式获取值，和ArrayList的方式相同

7 remove(int index)

public synchronized E remove(int index) {
    modCount++;
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    E oldValue = elementData(index);
    int numMoved = elementCount - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--elementCount] = null; // Let gc do its work
    return oldValue; //有返回值，删除索引下元素的值
}

根据索引删除的主要方法调用的System.arraycopy（）方法

7.1 arraycopy（）方法

public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);

可以看出原来的0元素被新复制过来的元素替换（可以实现删除数据）

把索引为5的后4个数字，复制到索引为4的位置，变成了123467899；这样索引为4的位置被索引为5的位置替换，实现了删除，在把最后一个赋值Null

8.总结

1.ctor的数据结构和ArrayList的数据结构相同都是数组实现的，特点也相同

2.阅读发现Vector类的很多关键方法都添加了sychronized关键字，所以是一个线程安全的动态数组。如果不需要线程安全，不建议选择，毕竟同步有额外的开销。