JDK源码分析-Vector

继承结构

• 可以看出Vector集合和ArrayList集成结构一样，其实内部方法也是大同小异，这里不常用，就做学习其实现原理。

构造方法

    protected Object[] elementData;
    protected int elementCount;
    protected int capacityIncrement;


    private static final long serialVersionUID = -2767605614048989439L;

    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(int initialCapacity) {
        this(initialCapacity, 0);
    }


    public Vector() {
        this(10);
    }

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

• 可以看出，Vector的构造函数和ArrayList的唯一区别在于多带了一个capacityIncrement的变量，这也导致数组的扩容方式有所不同。

扩容和增加数据

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

    public synchronized boolean add(E e) {
        modCount++;
        //复制前判断是否需要扩容
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }


    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;
        // 当Vector的容量不足以容纳当前的全部元素，增加容量大小。
        //若容量增长因子capacityIncrement > 0,数组扩容增加capacityIncrement个长度
         // 若容量增长因子capacityIncrement <= 0,数组扩容增加2倍  x2
        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);
    }

Vector和ArrayList有一定的不同

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

从这一句我们可以看出

   （增长容量）capacityIncrement > 0    增长倍数 ：数组数量（旧容量）+ 增长容量

 （ 增长容量）capacityIncrement<=0     增长倍数 ：数组数量（旧容量）+数组数量  也就2倍 x2

而ArrayList增长的倍数为1.5倍

线程安全性

1. Vector是线程安全的，可以看到方法上都是直接通过synchronized进行同步的。

小结

1. Vector也是内部也是数组实现
2. Vector增长方法和ArrayList大同小异，增长容量大于0则直接，旧容量+增长容量，当增长容量小于等于0，扩容为旧容量的2倍
3. Vector是线程安全性，内部使用synchronized同步方法，简单粗暴，缺点效率低。
4. 由于Vector使用不多，这里只学习内部原理。