【集合】Vector 源码分析

逃离我推掉我的手 2022-11-21 11:41 191阅读 0赞

# 前言 #

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

主要分析 JDK8 版本源码。

# 一 Vector 概述 #

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

Synchronized实现线程安全，而ArrayList是非线程安全的，理解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 实际应用当中还是比较少的，并发性很低。

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[Link 1]: https://blog.csdn.net/yhl_jxy/article/details/51760123
[ArrayList]: https://jpeony.blog.csdn.net/article/details/108910769