Vector<E>源码详解

Vector<E>源码详解(基于jdk1.8.0_162)

说明：Vector<E>底层使用了数组的方式实现，是一个线程安全的集合。

           该章只列举了常用的增删查改方法，其它可以参考JDK文档。

Stack<E>：栈的特性是“先进后出”，继承了Vector<E>类，实现的功能。

                    相当于栈的底层也是数组实现，也是一个线程安全的对象。

 

一）类图

Vector<E>继承了AbstractList<E>抽象类，实现了add、remove、set等功能。

Vector<E>继承了List<E>接口，依赖与Iterator<E>和ListIterator<E>接口，实现了数据迭代等功能。

Vector<E>是一个线程安全的集合。

备注：如需自己实现Vector类似的功能，可以继承AbstractList<E>抽象类，然后再自定义方法。

 

二）构造方法

1）Vector<E> vector = new Vector<E>();

构造一个容量默认为10、增量为0的空集合，当元素大小超出容量时，按（容量+容量）成倍的方式扩容。

2）Vector<E> vector = new Vector<E>(20);

构造一个指定容量为20、增量为0的空集合，当元素大小超出容量时，按（容量+容量）成倍的方式扩容。

3）Vector<E> vector = new Vector<E>(30,15);

构造一个指定容量为30、增量为15的空集合，当元素大小超出容量时，按（容量+增量）的方式扩容。

4）Vector<E> vector = new Vector<E>(Collection<? extends E> c);

构造一个包含指定元素集合的列表。

// 构造一个容量默认为10、增量为0的空集合，当元素大小超出容量时，按（容量+容量）成倍的方式扩容
public Vector() {
    this(10);
}

// 构造一个指定容量为20、增量为0的空集合，当元素大小超出容量时，按（容量+容量）成倍的方式扩容
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

// 构造一个指定容量为30、增量为15的空集合，当元素大小超出容量时，按（容量+增量）的方式扩容
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(); //把集合转换成一个Object[]数组
    elementCount = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class) // 符合条件,复制成一个新数组再赋值
        elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}

 

三）添加

1）add(E e)，一次添加一个元素，相当于在末尾添加，有返回值

     addElement(E obj)，一次添加一个元素，相当于在末尾添加，无返回值

public synchronized boolean add(E e) { // synchronized保证线程安全
    modCount++;
    ensureCapacityHelper(elementCount + 1); // 调用扩容方法
    elementData[elementCount++] = e; // 添加元素
    return true;
}

public synchronized void addElement(E obj) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = obj;
}

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0) // 判断是否需要扩容
        grow(minCapacity); // 调用扩容方法
}

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

private void grow(int minCapacity) {
    // overflow-conscious code