Vector 源码解析

1、简述

我们知道，数据结构中主要有两种存储结构，分别是：顺序存储结构（线性表）、链式存储结构（链表），在 Java 中，对这两种结构分别进行实现的类有：

• 顺序存储结构：Vector、Stack、ArrayList
• 链式存储结构：LinkedList、Queue

2、归纳

• 继承了 AbstractList 抽象类，实现了 List 接口，实现了 RandomAccess, Cloneable, java.io.Serializabl e接口，所以支持快速访问、复制(拷贝)、序列化。
• 基于泛型的一维数组实现，有序，允许 null 存在，支持动态扩容，默认容量为10，增长系数为0，两个值都是可以通过构造函数传递，扩容时，如果增长系数大于0，扩容的大小为现有容量大小加上增长系数值，如果增长系数小于0，则扩容2倍，如果还是不够则直接扩容要其需求之。
• Vector 的扩容方式是直接创建一个新的数组，并将数据拷贝到新数组中。
• 查和改操作速度非常快【时间复杂度：O(1)】,增和删操作相对较慢【时间复杂度：最快O(1)最慢O(n)】。
• Vector 的操作单线安全，加入了同步代码块，多线程安全（但不绝对），可以看成线程安全版本的 ArrayList（其实也不绝对，在使用还是会加锁操作）。
• 相比于 ArrayList 其效率低，因为加入了 synchronized 操作。

3、分析

3.1、接口

• 在分析 Vector 源码之前，我们先来看看集合的接口 List。

public interface List<E> extends Collection<E> {
    ...
    // 增
    boolean add(E e);
    void add(int index, E element);
    // 删
    boolean remove(Object o);
    E remove(int index);
    // 改
    E set(int index, E element);
    // 查
    E get(int index);
    ...
}

• 在上述接口中，我只抽取了比较重要的几个方法，然后以此为后续重点分析目标，其 List 接口对应的源码中远不止上述几个方法，有兴趣的同学可以自行翻阅。

3.2、成员变量

• 在 Vector 的源码中，其成员变量并不多，所以在此把它们都一一列出。

public class Vector<E> extends AbstractList<E> implements List<E>
        , RandomAccess, Cloneable, java.io.Serializable {
    
    // 序列化唯一表示 UID
    private static final long serialVersionUID = -2767605614048989439L;
    
    // 保存Vector中数据的数组
    protected Object[] elementData;

    // 实际数据的数量
    protected int elementCount;

    // 容量增长系数
    protected int capacityIncrement;
    
    /**
     * 最大容量，也就是一维数组长度的最大值
     * 为什么要“-8”操作？
     * 因为在要分配的数组的最大大小时，vm 会在一维数组中会保留一些。
     * 尝试分配更大的数组可能会导致 OutOfMemoryError:请求的数组大小超过VM限制
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    ...
    
}

3.3、构造函数

• 构造函数是一个类最常见的，同样也是最常被使用到的，接着我们分析 Vector 的三个不同的构造函数。

public class Vector<E> extends AbstractList<E> implements List<E>
        , RandomAccess, Cloneable, java.io.Serializable {
    
    ...
    
    /**
     * 无参构造函数
     */
    public Vector() {
        // 调用有一个参数传值的有参构造函数，默认容量为10
        this(10);
    }
    
    /**
     * 有参构造函数
     *
     * @param initialCapacity 数组容量
     * @throws IllegalArgumentException 不合法的参数异常
     */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    
    /**
     * 有参构造函数
     *
     * @param initialCapacity 数组容量
     * @param capacityIncrement 增长系数
     * @throws IllegalArgumentException 不合法的参数异常
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        // 如果 initialCapacity 不合法，抛出异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        // 设置新的数组，并且设置好数组容量
        this.elementData = new Object[initialCapacity];
        // 赋值增长系数
        this.capacityIncrement = capacityIncrement;
    }
    
    /**
     * 有参构造函数
     * 构造包含指定元素的列表集合
     *
     * @param c 集合元素
     * @throws NullPointerException 如果集合 c 为 null，则抛出空指针异常
     * @since   1.2
     */
    public Vector(Collection<? extends E> c) {
        // 将集合转换为数组
        elementData = c.toArray();
        // 设置数组的真实长度
        elementCount = elementData.length;
        // 判断其是不是 Object 对象，如果不是将其转换为 Object 对象数组
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

    ...
    
}

3.4、增

• ArrayList 的增操作有两种实现，分别为 add(E e) 和 add(int index, E element)，下面我们来分析其两种实现。

public class Vector<E> extends AbstractList<E> implements List<E>
        , RandomAccess, Cloneable, java.io.Serializable {
    
    ...
    /**
     * 将元素 e 添加到列表中
     *
     * @param e 元素 e
     * @return 返回 true 标识添加成功
     */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    
    /**
     * 将元素 element 添加到指定的索引位置
     *
     * @param index 要插入指定元素的索引
     * @param element 要插入的元素
     * @throws IndexOutOfBoundsException 如果索引角标不合法，则抛出索引越界异常
     */
    public synchronized void add(int index, E element) {
        insertElementAt(element, index);
    }
    
    /**
     * 看是否需要进行扩容操作
     *
     * @param minCapacity 容积，其实就是数组的容量大小
     */
    private void ensureCapacityHelper(int minCapacity) {
        // 当该 i f成立时，说明当前数组(容器)的空间不够了，需要扩容，所以调用 grow() 方法
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    /**
     * 增加容量以确保它至少可以容纳由最小容量参数指定的元素数目
     *
     * @param minCapacity 容积，其实就是数组的容量大小
     */
    private void grow(int minCapacity) {
        // 获取原始容积
        int oldCapacity = elementData.length;
        // 这里就是扩容到原始容量的2倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        // 如果扩容2倍后还不满足，则直接赋值到其所需的容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 如果扩容的容量大于整型的最大值，则进行异常处理或者赋值为整型最大值
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
         // 调用 rrays.copyOf() 创建一个新的数组并将数据拷贝到新数组中，最后让 elementData 进行引用
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    /**
     * 判断 minCapacity 是否溢出
     *
     * @param minCapacity 容积，其实就是数组的容量大小
     */
    private static int hugeCapacity(int minCapacity) {
        // 判断 minCapacity 是否小于零，小于则抛出异常
        if (minCapacity < 0) throw new OutOfMemoryError();
        // 判断 minCapacity 是否超过前边设置的默认成员变量的值，超过整型的边界值从而进行赋值
        return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
    }
    ...
    
}

3.5、删

• Vector的删操作有两种实现，分别是 remove(int index) 和 remove(Object o)，下面我们来分析其两种实现。

public class Vector<E> extends AbstractList<E> implements List<E>
        , RandomAccess, Cloneable, java.io.Serializable {
    ...
    /**
     * 删除索引为 index 的元素并返回
     *
     * @param index 要删除的索引
     * @return 返回删除的元素
     * @throws IndexOutOfBoundsException 抛出索引角标越界异常
     */
    public synchronized E remove(int index) {
        // 这是 Vector 的父类 AbstractList 中定义了一个 int 型的属性
        // 在此用来记录了 Vector 结构性变化的次数
        modCount++;
        // 判断索引是否合法性
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        // 获取要删除的元素
        E oldValue = (E) elementData[index];
        
        // 在执行删除操作时数组需要移动的元素个数
        int numMoved = size - index - 1;
        // (numMoved > 0)成立则将数组进行前移copy
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        // 因为数组有可能进行了整个前移1位，所以将最后一个索引对应的值置空，从而降 低GC
        elementData[--size] = null; 
        // 返回要删除的元素
        return oldValue;
    }
    
    /**
     * 删除元素 o，并且返回是否有效删除
     *
     * @param o 元素将从此列表中删除(如果存在)
     * @return 如果存在该元素将其删除并返回 true，否则返回 false
     */
    public boolean remove(Object o) {
        return removeElement(o);
    }
    
    /**
     * 删除元素 obj，并且返回是否有效删除
     *
     * @param obj 元素将从此列表中删除(如果存在)
     * @return 如果存在该元素将其删除并返回 true，否则返回 false
     */
    public synchronized boolean removeElement(Object obj) {
        // 用来记录了 Vector 结构性变化的次数
        modCount++;
        // 获取当前元素 obj 的索引位置
        int i = indexOf(obj);
        // 索引大于等于0代表该元素存在，否则不存在
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }
    
    /**
     * 检索元素 o 的索引坐标
     *
     * @param o 元素 o
     * @return 返回元素 o 的索引坐标，如若不存在则返回-1
     */
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }
    
    /**
     * 检索元素 o 的索引坐标
     *
     * @param o 元素 o
     * @param index 从什么位置开始检索
     * @return 返回元素 o 的索引坐标，如若不存在则返回-1
     */
    public synchronized int indexOf(Object o, int index) {
        // 这里把空和非空进行区分，空的话用“==”判断，非空用“equals”判断
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    
    /**
     * 删除元素 obj，并且返回是否有效删除
     *
     * @param obj 元素将从此列表中删除（如果存在）
     * @return 如果存在该元素将其删除并返回 true，否则返回 false
     */
    public synchronized void removeElementAt(int index) {
        // 用来记录Vector结构性变化的次数
        modCount++;
        // 判断索引位置是否合法，不合法抛出异常
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        // 在执行删除操作时数组需要移动的元素个数
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        // 因为数组有可能进行了整个前移1位，所以将最后一个索引对应的值置空，从而降低 GC
        elementCount--;
        elementData[elementCount] = null; 
    }
    ...
}

3.6、改

• Vector的改操作有一种实现，对应的是 set(int index, E element)，下面我们来分析这种实现。

public class Vector<E> extends AbstractList<E> implements List<E>
        , RandomAccess, Cloneable, java.io.Serializable {
    ...
    /**
     * 修改索引角标为 index 的元素值
     *
     * @param index 要修改的索引坐标
     * @param element 修改后存储的元素值
     * @return 返回修改前的元素值
     * @throws IndexOutOfBoundsException 抛出索引角标越界异常
     */
    public synchronized E set(int index, E element) {
        // 判断索引是否合法性
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        
        // 获取原本index的元素值
        E oldValue = elementData(index);
        // 将其替换成新的元素值
        elementData[index] = element;
        // 返回修改前的元素值
        return oldValue;
    }
    ...
}

3.7、查

• Vector的查操作有一种实现，对应的是 get(int index)，下面我们来分析这种实现。

public class Vector<E> extends AbstractList<E> implements List<E>
        , RandomAccess, Cloneable, java.io.Serializable {
    ...
    /**
     * 查找索引角标为index的元素值
     *
     * @param index 要修改的索引坐标
     * @return 返回查找到的索引为 index 的元素值
     * @throws IndexOutOfBoundsException 抛出索引角标越界异常
     */
    public synchronized E get(int index) {
        // 判断索引是否合法性
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        // 返回查找到的索引为 index 的元素值
        return elementData(index);
    }
    ...
}