在java提高篇（二一）—–ArrayList、java提高篇（二二）—LinkedList，详细解说了ArrayList、linkedList的原理和实现过程，对于List接口这里还介绍一个它的实现类Vector，Vector 类能够实现可增长的对象数组。
一、Vector简单介绍
Vector能够实现可增长的对象数组。与数组一样，它包括能够使用整数索引进行訪问的组件。只是，Vector的大小是能够添加�或者减小的，以便适应创建Vector后进行加入�或者删除操作。
Vector实现List接口，继承AbstractList类，所以我们能够将其看做队列，支持相关的加入�、删除、改动、遍历等功能。
Vector实现RandmoAccess接口，即提供了随机訪问功能，提供提供高速訪问功能。在Vector我们能够直接訪问元素。
Vector 实现了Cloneable接口，支持clone()方法，能够被克隆。
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.SerializableVector提供了四个构造函数：
/**
* 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
*/
public Vector() {
this(10);
}
/**
* 构造一个包括指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
*/
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);
}
/**
* 使用指定的初始容量和等于零的容量增量构造一个空向量。
*/
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
/**
* 使用指定的初始容量和容量增量构造一个空的向量。
*/
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}在成员变量方面，Vector提供了elementData , elementCount， capacityIncrement三个成员变量。当中
elementData ："Object[]类型的数组"，它保存了Vector中的元素。依照Vector的设计elementData为一个动态数组，能够随着元素的添加�而动态的增长，其详细的添加�方式后面提到（ensureCapacity方法）。假设在初始化Vector时没有指定容器大小，则使用默认大小为10.
elementCount：Vector 对象中的有效组件数。
capacityIncrement：向量的大小大于其容量时，容量自己主动添加�的量。假设在创建Vector时，指定了capacityIncrement的大小；则，每次当Vector中动态数组容量添加�时>，添加�的大小都是capacityIncrement。假设容量的增量小于等于零，则每次须要增大容量时，向量的容量将增大一倍。
同一时候Vector是线程安全的！
二、源代码解析
对于源代码的解析，LZ在这里仅仅就添加�（add）删除（remove）两个方法进行解说。
2.1添加�：add(E e)
add(E e)：将指定元素加入�到此向量的末尾。
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1); //确认容器大小，假设操作容量则扩容操作
elementData[elementCount++] = e; //将e元素加入�至末尾
return true;
}这种方法相对而言比較简单，详细过程就是先确认容器的大小，看是否须要进行扩容操作，然后将E元素加入�到此向量的末尾。
private void ensureCapacityHelper(int minCapacity) {
//假设
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* 进行扩容操作
* 假设此向量的当前容量小于minCapacity，则通过将其内部数组替换为一个较大的数组俩添加�其容量。
* 新数据数组的大小姜维原来的大小 + capacityIncrement，
* 除非 capacityIncrement 的值小于等于零，在后一种情况下，新的容量将为原来容量的两倍，只是，假设此大小仍然小于 minCapacity，则新容量将为 minCapacity。
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length; //当前容器大小
/*
* 新容器大小
* 若容量增量系数(capacityIncrement) > 0，则将容器大小添加�到capacityIncrement
* 否则将容量添加�一倍
*/
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
/**
* 推断是否超出最大范围
* MAX_ARRAY_SIZE：private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}对于Vector整个的扩容过程，就是依据capacityIncrement确认扩容大小的，若capacityIncrement <= 0 则扩大一倍，否则扩大至capacityIncrement 。当然这个容量的最大范围为Integer.MAX_VALUE即，2^32 - 1，所以Vector并非能够无限扩充的。
2.2、remove(Object o)
/**
* 从Vector容器中移除指定元素E
*/
public boolean remove(Object o) {
return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj); //计算obj在Vector容器中位置
if (i >= 0) {
removeElementAt(i); //移除
return true;
}
return false;
}
public synchronized void removeElementAt(int index) {
modCount++; //改动次数+1
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) {
//从指定源数组中复制一个数组，复制从指定的位置開始，到目标数组的指定位置结束。
//也就是数组元素从j位置往前移
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--; //容器中有效组件个数 - 1
elementData[elementCount] = null; //将向量的末尾位置设置为null
}由于Vector底层是使用数组实现的，所以它的操作都是对数组进行操作，仅仅只是其是能够随着元素的添加�而动态的改变容量大小，事实上现方法是是使用Arrays.copyOf方法将旧数据复制到一个新的大容量数组中。Vector的整个内部实现都比較简单，这里就不在重述了。
三、Vector遍历
Vector支持4种遍历方式。
3.1、随机訪问
由于Vector实现了RandmoAccess接口，能够通过下标来进行随机訪问。
for(int i = 0 ; i < vec.size() ; i++){
value = vec.get(i);
}3.2、迭代器
Iterator it = vec.iterator();
while(it.hasNext()){
value = it.next();
//do something
}3.2、for循环
for(Integer value:vec){
//do something
}3.4、Enumeration循环
Vector vec = new Vector<>();
Enumeration enu = vec.elements();
while (enu.hasMoreElements()) {
value = (Integer)enu.nextElement();
}——————————————————————————————————————————————————————————————————————————-- 原文出自：http://cmsblogs.com/?p=1180。尊重作者的成果，转载请注明出处！
-- 个人网站：http://cmsblogs.com