JDK源码分析-Vector

迷南。 2023-02-25 08:33 46阅读 0赞

## 继承结构 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3MDI2NjAz_size_16_color_FFFFFF_t_70][]

*  可以看出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使用不多，这里只学习内部原理。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI3MDI2NjAz_size_16_color_FFFFFF_t_70]: /images/20230209/c02747db74d94d6aa8e6b801385de0c5.png