目录
Vector是实现了List接口的子类，其底层是一个对象数组，维护了一个elementData数组，是线程安全的，Vector类的方法带有synchronized关键字，在开发中考虑线程安全中使用Vector。
如下图所示：
观察上图，发现Vector继承了AbstractList<E>，并实现了三个接口，分别是：Serializable、Cloneable和RandomAccess。下面对Vector中继承的类和实现的接口进行简单的介绍：
public Vector() {
this(10);
}总结：Vector的无参构造方法中会调用有参构造方法，创建一个内部数组，该内部数组的初始容量为10，增量为0
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}总结：构造一个内部数组，该数组的容量为指定的容量，增量为0。
public Vector(int initialCapacity, int capacityIncrement) {
super();
//如果初始容量小于0，抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
//指定容量
this.elementData = new Object[initialCapacity];
//指定增量
this.capacityIncrement = capacityIncrement;
}总结：构造一个具有初始容量和增量的数组。
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底层也是数组实现的，其主要变量有：
从上面对于Vector构造方法的分析，不难发现Vector和ArrayList的默认初始容量都是10。那么，我们看看Vector的add()方法又是如何实现的？
public synchronized boolean add(E e) {
//AbstractList中的变量
modCount++;
//确保数组容量是否足够
ensureCapacityHelper(elementCount + 1);
//把元素添加到数组中
elementData[elementCount++] = e;
return true;
}可以看到：add方法添加一个元素到列表的末尾。它首先通过ensureCapacityHelper(elemetnCount+1)来保证Object[]数组有足够的空间存放添加的数据，然后再将添加的数据存放到数组对应位置上。
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}通过ensureCapacityHelper()方法判断最小容量和当前数组长度，若所需的最小容量大于数组大小，则需要进行扩容，然后调用grow()方法实现扩容。
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
//旧数组的长度
int oldCapacity = elementData.length;
//如果指定了增量，则新数组长度=旧数组长度+增量；如果没有指定容量，则新数组长度=旧数组长度2倍
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
//判断新容量减去最小容量是否小于0，如果是第一次调用add，则必然小于
if (newCapacity - minCapacity < 0)
//将最小容量赋给新容量
newCapacity = minCapacity;
/判断新容量减去最大数组大小是否大于0，如果时则计算出一个超大容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//调用数组工具类方法，创建一个新数组，将新数组的地址赋值给elementData
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
//如果最小容量小于0，抛出异常；否则就比较并返回
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}Step1：先将当前数组大小赋值给oldCapacity，然后判断是否有指定增量的值，如果有，则新数组长度=旧数组长度+增量；如果没有，则新数组长度=旧数组长度*2。
Step2：利用newCapacity进行两次判断：
Step3：最终得到newCapacity，然后调用Arrays.copyOf（）方法进行扩容
综合上述分析，有以下几个点：
接下来可以看看如何在指定位置添加元素：
//在指定位置添加元素
public void add(int index, E element) {
insertElementAt(element, index);
}
//添加元素到指定位置
public synchronized void insertElementAt(E obj, int index) {
modCount++;
//检查位置合法性
if (index > elementCount) {
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}
//判断是否需要扩容
ensureCapacityHelper(elementCount + 1);
//拷贝数组
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
//添加元素
elementData[index] = obj;
elementCount++;
}可以看到：在指定位置添加元素，首先进行了数组范围的检查，防止越界，然后调用方法检验是否要扩容，且增量++，之后完成数组拷贝即可。
public boolean remove(Object o) {
return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
modCount++;
//获取该元素所在的数组下标
int i = indexOf(obj);
//如果该元素存在，则移除元素
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}
public synchronized void removeElementAt(int index) {
modCount++;
//如果下标越界，抛出异常
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
else if (index < 0) { //下标小于0，抛出异常
throw new ArrayIndexOutOfBoundsException(index);
}
//删除元素
int j = elementCount - index - 1;
if (j > 0) {
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--;
elementData[elementCount] = null; /* to let gc do its work */
}由上述分析：删除元素同样需要进行范围校验。然后计算删除需要移动的数据，再通过数组拷贝移动数组。其次还有一个小细节，可以发现remove()方法是有返回值的，而这个返回值就是我们删除的元素的值。 同样的，真正移除元素的remove()方法也是加锁了的。
该方法加了synchronized关键字保证安全性，用来设置指定下标的数据，进行元素数据的更新。
public synchronized E set(int index, E element) {
//判断合法性
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
//修改旧值
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}该方法用来获取对应下标的数据，也是加锁的方法。
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}Vector中的其他方法，如：判断是否为空、获取长度等方法，都是加了锁的。因此，可以认为Vector是线程安全的。
关于Vector中的迭代器，这里不再赘述，有兴趣的可以看这篇文章，里面对Itr进行了介绍：深入理解ArrayList
相同：两个类都实现了List接口，它们都是有序且元素可重复的集合。
不同：
（1）ArrayList 是线程不安全的，Vector 是线程安全的。ArrayList 是线程不安全的，所以当我们不需要保证线程安全性的时候推荐使用 ArrayList，如果想要在多线程中使用 ArrayList 可以通过 Collections.synchronizedList(new ArrayList()) 或 new CopyOnWriteArrayList 的方式创建一个线程安全的 ArrayList 集合；Vector 类的所有方法都是同步的。可以有两个线程安全的访问一个 Vector 对象，但是一个线程访问 Vector 的话会在同步操作上耗费大量的时间。
（2）ArrayList 使用默认构造器创建对象时是在调用 add() 方法时对 ArrayList 的默认容量进行初始化的，Vector 在调用构造器时就对容量进行了初始化
（3）ArrayList 存储数据的 Object 数组使用了transient关键字，Vector 的 Object 数组没有。
关于transient关键字的说明：如果用 transient 声明一个实例变量，当对象存储时，它的值不需要维持。这里的对象存储是指，Java 的 serialization 提供的一种持久化对象实例的机制。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。例如：当持久化对象时，可能有一个特殊的对象数据成员，我们不想用 serialization 机制来保存它。为了在一个特定对象的一个域上关闭 serialization，可以在这个域前加上关键字 transient。
简单的说，就是被 transient 修饰的成员变量，在序列化的时候其值会被忽略，在被反序列化后， transient 变量的值被设为初始值， 如 int 型的是 0，对象型的是 null。
（4）扩容机制不同。ArrayList扩容机制为变为原来的1.5倍，而Vector扩容时如果指定了增量，则新数组长度=旧数组长度+增量，如果没有指定，就扩容为原来的2倍。