《Java源码分析》：Vector
虽然，Vector集合在我们的编程中，使用的比较少，至少我使用的比较少，一般情况下，我都是倾向于使用List来存储一些同类型的元素。
其实，Vector的内部实现和ArrayList的内部实现基本一致，内部都是借助于数组来实现的。下面就一起来分析下。
HashMap类的源码分析，博客在这里：http://blog.csdn.net/u010412719/article/details/51980632
Hashtable类的源码分析，博客在这里：http://blog.csdn.net/u010412719/article/details/51972602
LinkedHashMap类的源码分析，博客在这里：http://blog.csdn.net/u010412719/article/details/51984455
1、Vector的继承结构
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable从继承结构可以看出，Vector继承了AbstractList抽象类并实现了List、RandomAccess、Cloneable、Serializable接口，ArrayList的结构Vector一样。
RandomAccess接口是在源码中的注释如下：Marker interface used by List implementations to indicate that
they support fast (generally constant time) random access.翻译下就是：这是一个标记性的接口，谁实现了这个接口就表明他具有快速随机访问的能力。
2、Vector的属性
elementData:数组，用来存放元素的
elementCount:记录数组中已经保存了的数据的个数
capacityIncrement：自动扩容的大小，即当数组满了之后，就添加capacityIncrement个空间装载元素，如果capacityIncrement<=0,则扩容时就扩容到目前Vector容量的两倍
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
3、Vector构造函数
/*
其它的构造函数都是调用此构造函数
参数的说明
initialCapacity:指定的初始容量，默认值为10
capacityIncrement：指定的每次的扩容大小，默认值是0，
capacityIncrement=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;
}
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
public Vector() {
this(10);
}
当我们使用使用Vector时，如果我们知道Vector存储的元素大概会达到多少，就指定Vector的容量，当存储数量比较大时，就不要使用 Vector v= new Vector()来创建Vector实例对象，这个实际上就是创建了长度为10 ，增长因子为0 的Object 数组。当存储数量比较大时，会添加扩容后复制原来的数组中的元素到新数组中带来的开销。
Vector类中还有如下一个用Collection初始化Vector对象实例的构造函数
内部实现时直接将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);
}add(E e)方法
添加元素的方法实现比较简单：直接在数组的后一个位置添加即可，不过在添加元素之前需要检查数组中是否已满，如果已满，则扩容。
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
扩容在Vector中是不可避免的，因此需要了解下ensureCapacityHelper函数
ensureCapacityHelper
这个函数，就是检查数组是否已满，如果已满，则调用grow函数进行扩容。扩容之后进行数据的拷贝即可。
其中，在grow函数中如果扩容后的数据进行一些判断，例如检测是否溢出呀，检测是否达到了MAX_ARRAY_SIZE呀，分别对这些进行了一些处理。
思路比较简单，因此源码也就比较容易看懂。
ArrayList类的扩容与这个一模一样。
源码如下：(添加了一些注释)
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
//当数组已满，则调用grow函数来对数组进行扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//扩容的大小由capacityIncrement决定，如果capacityIncrement<=0,则扩容到目前数组的两倍
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
//检查是否newCapacity溢出了
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//进行元素的拷贝
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}add(int index, E element)
函数的功能：在指定位置添加元素
方法实现的思想也比较简单：首先检查是否需要扩容，如果需要，则进行扩容；接着将数组从索引index开始的元素全部向后移动一位。最后将元素保存在数组的index位置即可。
源码如下：（添加了一点注释）
//在指定位置添加元素
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++;
}
get(int index)方法
容器关键的两个方法分别为：添加元素、取出元素。因此，不可避免的我们需要分析下get方法的实现思路。
get方法就更简单了，由于Vector是借助于数组来实现的，因此get方法的内部实现也就是取出位置为index的元素。
public synchronized E get(int index) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
上面的get、add方法都是用了synchronized关键字进行修饰，说明他们是线程安全的，在多线程并发时，不需要我们进行额外的同步。而ArrayList是没有进行同步的。这也是Vector和ArrayList的一个区别
set(int index, E element)方法
既然我们知道Vector底层是基于数组来实现的，则set方法我们用屁股都想得到是怎么实现的，比较简单哈。
public synchronized E set(int index, E element) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}remove(Object o)方法
函数的功能：去除掉元素o。
思路：先找到该元素在数组中的位置index；然后移除索引位置为index的元素即可
思路清晰之后，源码也就比较好理解了。
源码如下：（添加了一些注释）
/*
函数的功能：去除掉元素o。
思路：先找到该元素在数组中的位置index；然后移除索引位置为index的元素即可
*/
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 int indexOf(Object o) {
return indexOf(o, 0);
}
/*
函数的功能：找到元素o在数组在index位置后出现的位置
*/
public synchronized int indexOf(Object o, int index) {
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;
}
public synchronized void removeElementAt(int index) {
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);
}
elementCount--;
elementData[elementCount] = null; /* to let gc do its work */
}
上面的去除掉元素，Vector还提供了remove另外一种形式，
remove(int index)
函数功能：去除掉Vector索引为index位置的元素。
这个源码的实现也比较简单，源码如下：
public synchronized E remove(int index) {
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--elementCount] = null; // Let gc do its work
return oldValue;
}elements方法
方法中创建了一个枚举类型，里面实现还是通过元素是否存在，通过下标遍历数组，这里就过多的进行介绍。
public Enumeration<E> elements() {
return new Enumeration<E>() {
int count = 0;
public boolean hasMoreElements() {
return count < elementCount;
}
public E nextElement() {
synchronized (Vector.this) {
if (count < elementCount) {
return elementData(count++);
}
}
throw new NoSuchElementException("Vector Enumeration");
}
};
}
小结
Vector里面还有很多方法，我们只需要知道Vector里面是基于数组来实现的，然后用正常的思维来思考常见的方法的实现也没有任何问题的，这里就不做过多的介绍了。需要注意的是：Vector是线程安全的，因此，在多线程并发中是不需要使用额外同步的，而ArrayList实现基本与Vector一样，但是区别是：ArrayList是线程不安全的，在多线程并发时，需要我们进行额外的同步