简介
本节来介绍Vector ,他也是List接口下早期的用来存储数据的工具类之一（现在用的并不多），而且一定要注意是在多线程情况中才采用，也就意味着他是多线程应用中，用来存储数据的一个集合，最主要需要意识到，其实它是线程安全的。
仍然从基础的数据结构，整个类的继承和实现的体系来了解，Vector可以做那些事情。（注意：新的jdk中一定要知道另一个类就是CopyOnWriteArrayList），后续文章会讲解CopyOnWriteArrayList，这里只做一个简单的阐述，让读者有一个简单的印象。
1.首先Vector同ArrayList一样是基于对象数组的。因此增删比较快，因为设计到线程安全操作的处理，意味着效率会比ArrayList低。（常见面试题之一，ArrayList与Vector的区别），最主要的就是一个线程安全，一个线程不安全。
2.Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。RandmoAccess 是 java 中用来被List 实现，为 List 提供快速访问功能的。在 Vector 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。其实就是快速从索引来访问。
3.Vector 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
4.Vector 实现java.io.Serializable接口，这意味着 Vector 支持序列化，能通过序列化去传输。
5.Vector是线程安全的，这是最重要的一点一定要记住，这也是Vector存在的意义。
简单阐述一下就是，和AarryList最大的区别就是线程的问题。其余你可以大致按照ArrayList来理解，也不会有太大的偏差。但是本文还会针对一些处理细节，逐步分析它的源码，以便更深入的了解。
继承实现体系：
注意：这里你最需要理解到的就是其实和ArrayList没有什么区别。如果你了解了ArrayList，这里就会轻松多了。
构造函数
Vector共有四个构造函数。分别为：
1. 构造指定初始容量的向量，和每次扩容数量。
/**
* 构造指定初始容量的向量，和每次扩容数量。
* @param initialCapacity the initial capacity of the vector
* @param capacityIncrement the amount by which the capacity is
* increased when the vector overflows
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
//这里同样是初始化一个object数组。
this.elementData = new Object[initialCapacity];
//这里标记了扩容的数量，和下面的方法对应。
this.capacityIncrement = capacityIncrement;
}
注意，这里制定了扩容的数量，可以看一下，从add(e)方法开始跟，和ArrayList一样的道理，最后到newCapacity()方法。
/**
* 扩容操作，返回新的数组容量
*
* @param minCapacity the desired minimum capacity
* @throws OutOfMemoryError if minCapacity is less than zero
*/
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//如果没有capacityIncrement>0那么根据我们指定的容量库容。
//否则扩容为原来的二倍。（oldCapacity+ oldCapacity）
//还要记住，这里和Arraylist扩容数量是有区别的（ArrayList是1.5倍）。
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity <= 0) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return minCapacity;
}
return (newCapacity - MAX_ARRAY_SIZE <= 0)
? newCapacity
: hugeCapacity(minCapacity);
}
2. 构造指定容量的的向量，扩容数量为0.
/**
* 构造指定容量的的向量，扩容数量为0.
* 注意：扩容数量为0不代表它就不扩容了，稍后分析便可知道。
*
* @param initialCapacity the initial capacity of the vector
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
3. 默认的构造函数.
/**
*构造的默认容量为10
*
*/
public Vector() {
this(10);
}
4. 以一个集合为参数，构造一个初始化向量.
/**
* *构造一个包含指定元素的向量集合，按照集合返回的顺序迭代器。
*
* @param c the collection whose elements are to be placed into this
* vector
* @throws NullPointerException if the specified collection is null
* @since 1.2
*/
public Vector(Collection<? extends E> c) {
//转成object数组
elementData = c.toArray();
elementCount = elementData.length;
// defend against c.toArray (incorrectly) not returning Object[]
// (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
//注意：这里是个bug，后续讲解为什么添加了判断。当然你也可以直接访问上面的地址，看一下具体的原因。
if (elementData.getClass() != Object[].class)
//调用Arrays.copyOf，这里再Arraylist已经阐述过
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}
synchronized关键字
这里先对 synchronized 做一个简单说明，通过 synchronized 可以达到被修饰的方法变成线程安全的。
1.synchronized可以修饰实例方法。
2.synchronized可以修饰静态方法。
3.synchronized可以修饰代码块。
这里只有一个印象即可。而且注意：之前说效率不如ArrayList原因就是此关键字加大系统一部分的开销。
add()
add()相对于 ArrayList 的add()，增加里 synchronized 关键字，变成了线程安全的方法，而且不光有这一个方法，，因为Vector是线程安全的list，其实根据规律可以总结出来，Vector中所有涉及到元素改动的方法全都用 synchronized 来修饰。
/**
* 添加一个元素到vector末尾。
*
* @param e element to be appended to this Vector
* @return {@code true} (as specified by {@link Collection#add})
* @since 1.2
*/
public synchronized boolean add(E e) {
modCount++;
add(e, elementData, elementCount);
return true;
}
add()方法实践
上面阐述了，Vector是一个线程安全的类。这里做一个简单实验，来更加深刻的了解一下Vector，同时用ArrayList来对比，体现出二者的差别。
package com.vetor;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
public class Vectorlist extends Thread{
static Vector<Integer> vector = new Vector();
static List<Integer> list = new ArrayList<Integer>();
public void run()
{
for(int i = 0;i<500;i++){
vector.add(i);
list.add(i);
}
}
public static void main(String [] args) throws InterruptedException {
Vectorlist vectorlist = new Vectorlist();
Thread thread1 = new Thread(vectorlist);
Thread thread2 = new Thread(vectorlist);
Thread thread3 = new Thread(vectorlist);
Thread thread4 = new Thread(vectorlist);
Thread thread5 = new Thread(vectorlist);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
//此处可以等待，或者休眠等待数组添加完毕，不然获取不到正确的size。
Thread.sleep(3000);
System.out.println("vector size = "+vector.size()+" ");
System.out.println("list size = "+ list.size()+" ");
}
输出结果：
这里vector的size每次都是2500，而list的size则不为2500，注意在线程不安全下的情况下，元素存储进去不能得以保障，也有可能是其他值。
vector size = 2500
list size = 2225
remove()
/**
* 删除指定元素
*
* @param o element to be removed from this Vector, if present
* @return true if the Vector contained the specified element
* @since 1.2
*/
public boolean remove(Object o) {
return removeElement(o);
}
/**
* 首先查找，删除，然后改变索引。
*
* @param obj the component to be removed
* @return {@code true} if the argument was a component of this
* vector; {@code false} otherwise.
*/
public synchronized boolean removeElement(Object obj) {
modCount++;
//查找指定元素的索引
int i = indexOf(obj);
if (i >= 0) {
//删除指定索引的元素，然后处理索引，removeElementAt就不做详细解释了。 arraylist 套路其实是一样的。
removeElementAt(i);
return true;
}
return false;
}
总结
1.最重要的一点就是要记住，Vector是线程安全的。同时也用具体的代码来证明了和ArrayList的区别。
2.目前Vector应用情况已经不是特别多，在多线程编程中。一定要看一下文中说到的CopyOnWriteArrayList，要知道二者的区别。
3.我并没有罗列Api哪些方法可以做什么事情。我相信通过详细介绍这几个方法，可以达到抛砖引玉的作用，让你跟自发的深入了解Vector，或者其他的源码做了哪些事情。
4.一定要总结规律！！！
