一、简述
我们知道，数据结构中主要有两种存储结构，分别是：顺序存储结构（线性表）、链式存储结构（链表），在Java中，对这两种结构分别进行实现的类有：
- 顺序存储结构：ArrayList、Vector、Stack
- 链式存储结构：LinkedList、Queue
二、归纳
- 继承了AbstractList抽象类，实现了List接口，实现了RandomAccess, Cloneable, java.io.Serializable接口，所以支持快速访问、复制(拷贝)、序列化。
- 基于泛型的一维数组实现，有序，允许null存在，支持动态扩容，默认容量为10，增长系数为0，两个值都是可以通过构造函数传递，扩容时，如果增长系数大于0，扩容的大小为现有容量大小加上增长系数值，如果增长系数小于0，则扩容2倍，如果还是不够则直接扩容要其需求之。
- Vector的扩容方式是直接创建一个新的数组，并将数据拷贝到新数组中。
- 查和改操作速度非常快【时间复杂度：O(1)】,增和删操作相对较慢【时间复杂度：最快O(1)最慢O(n)】。
- Vector的操作单线安全，加入了同步代码块，多线程安全（但不绝对），可以看成线程安全版本的ArrayList（其实也不绝对，在使用还是会加锁操作）。
- 相比于ArrayList其效率低，因为加入了synchronized操作。
三、分析
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接口对应的源码中远不止上述几个方法，有兴趣的同学可以自行翻阅。
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、构造函数
构造函数是一个类最常见的，同样也是最常被使用到的，接着我们分析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);
}
...
}
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) {
// 当该if成立时，说明当前数组(容器)的空间不够了，需要扩容，所以调用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);
// 调用Arrays.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;
}
...
}
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;
}
...
}
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;
}
...
}
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);
}
...
}
