【集合】Vector 源码分析

前言

Github：https://github.com/yihonglei/jdk-source-code-reading（java-collection）

主要分析 JDK8 版本源码。

一 Vector 概述

Vector日常应用中不常用，底层也是基于数组实现的（数组数据结构），跟ArrayList最大的区别就是Vector通过

Synchronized实现线程安全，而ArrayList是非线程安全的，理解ArrayList（ArrayList源码分析），Vector几乎也都理解了。

二 Vector 实例

来个简单的demo。

package com.jpeony.collection.list;

import java.util.Vector;

/**
 * @author yihonglei
 */
public class VectorTest {
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<>();

        vector.add(1);
        vector.add(2);
        vector.add(3);

        for (Integer e : vector) {
            System.out.println(e);
        }
    }
}

三 Vector 底层实现

主要看下Vector的 add() 和 get() 方法。

Vector成员变量

// 存储元素的数组
protected Object[] elementData;

// 数组元素个数
protected int elementCount;

// 扩容时使用
protected int capacityIncrement;

Vector默认构造器

创建一个默认大小为10的数组。

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);
    // 创建一个默认大小为10的数组
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

Vector#add()实现

add() 处理扩容操作，并往数组添加元素。

public synchronized boolean add(E e) {
	// 对容器操作次数记录，主要用于处理并发判断
    modCount++;
    // 处理扩容操作
    ensureCapacityHelper(elementCount + 1);
   	// 往数组添加元素
    elementData[elementCount++] = e;
    return true;
}

Vector 线程安全是通过方法上的 synchronized对象锁保证的，包括 get() 方法等操作。

ensureCapacityHelper()处理扩容操作。 

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

grow()扩容实现。

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 通过capacityIncrement自定义扩容容量，默认按2倍扩容，跟ArrayList的扩容步长不一样。
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    // 容器溢出拦截，Vector最大容量不能超过Interger的最大值。
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 旧数组复制到新数组，用新的数组覆盖容器的elementData数组，完成扩容操作。
    elementData = Arrays.copyOf(elementData, newCapacity);
}

Vector#get()实现

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

    return elementData(index);
}

get()的操作也是线程安全的，通过synchronized对象锁保证，获取元素就是数组的基本操作，根据下标随机访问数组，

时间复杂度为O(1)。 

四 总结

1、Vector 底层基于数组实现，通过synchronized对象锁加锁保证线程安全；

2、Vector 扩容比 ArrayList 灵活，可以自己定义步长，默认是2倍扩容，ArrayList 是近似 1.5 倍扩容。

3、Vector 实际应用当中还是比较少的，并发性很低。