Vector概述
1.Vector是一个矢量队列，底层基于数组实现
2.Vector继承于AbstractList，实现了List, RandomAccess, Cloneable这些接口
3.Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
4.Vector里面的元素都是有序可重复的
5.Vector 是线程安全的，但也导致了性能要低于ArrayList
由于Vector与ArrayList极其的相似，这里做一个对比：ArrayList源码解读
相同点：
1.底层都是数组
2.增删查的操作基本类似
3.初始长度都为10
4.继承类和实现的接口相同
不同点：
1.Vector中方法都加了synchronized关键字保证线程安全，ArralList线程不安全
2.Vector新增capacityIncrement容量增长因子参数，用于扩容机制。capacityIncrement>0，扩容至（原数组size+capacityIncrement）大小
3.Vector扩容机制增长1倍（capacityIncrement==0），ArrayList扩容1.5倍
4.Vector变量用protected修饰，ArrayList用的private修饰
Vector类图：
Vector源码解读
1.Vector定义（与ArrayList一样）
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
2.Vector定义的变量
// Vector实际存放数据的数组
protected Object[] elementData;
// 数组大小
protected int elementCount;
// 容量增长系数
protected int capacityIncrement;
3.Vector构造器
（1）指定初始化数组大小和容量增长系数的构造器
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
（2）指定初始化数组大小和容量增长系数为0的构造器
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
（3）指定默认构造数组大小为10，容量增长系数为0的构造器
public Vector() {
this(10);
}
（4）指定集合的构造器
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);
}
4.添加一个元素add()方法
// 添加一个元素
public synchronized boolean add(E e) {
// 操作计数+1
modCount++;
// 判断是否扩容，需扩容则扩容
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
// 判断是否扩容，需扩容则扩容
private void ensureCapacityHelper(int minCapacity) {
if (minCapacity - elementData.length > 0)
// 扩容
grow(minCapacity);
}
//扩容
private void grow(int minCapacity) {
// 原数组大小
int oldCapacity = elementData.length;
/* 新数组大小
当Vector的容量不足以容纳当前的全部元素，增加容量大小。
若容量增长因子capacityIncrement > 0,数组扩容增加capacityIncrement个长度
若容量增长因子capacityIncrement <= 0,数组扩容增加1倍
*/
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);
}
5.删除一个元素方法remove()
JDK提供2个remove移除方法，分别是根据元素移除和根据下标移除。
根据元素移除元素：
// 移除某个元素
public boolean remove(Object o) {
return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
// 操作计数+1
modCount++;
// 取得移除元素的下标位置
int i = indexOf(obj);
if (i >= 0) {
// 根据下标位置移除元素
removeElementAt(i);
return true;
}
return false;
}
public synchronized void removeElementAt(int index) {
// 操作计数+1
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
elementCount--;
// 清空原数组最后一个位置元素为null
elementData[elementCount] = null; /* to let gc do its work */
}
根据下标移除元素：
// 根据下标移除某个元素
public synchronized E remove(int index) {
// 操作计数+1
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);
// 清除最后一个元素赋值为null，数组大小-1
elementData[--elementCount] = null; // Let gc do its work
return oldValue;
}
// 根据下标取得元素
E elementData(int index) {
return (E) elementData[index];
}
6.取得一个元素get()
// 根据下标取得元素
E elementData(int index) {
return (E) elementData[index];
}
Vector遍历方式
1.迭代器
Iterator iterator = vector.iterator();
while (iterator.hasNext()){
iterator.next();
}
2.随机访问
Integer value = null;
int size = vector.size();
for (int i=0; i<size; i++) {
value = (Integer)vector.get(i);
}
3.java 8新特性
vector.forEach(a -> {});
4.foreach循环
Integer value = null;
for (Integer integ:vec) {
value = integ;
}
5.Enumeration遍历
Integer value = null;
Enumeration enu = vec.elements();
while (enu.hasMoreElements()) {
value = (Integer)enu.nextElement();
}
Vector所有API
synchronized boolean add(E object)
void add(int location, E object)
synchronized boolean addAll(Collection<? extends E> collection)
synchronized boolean addAll(int location, Collection<? extends E> collection)
synchronized void addElement(E object)
synchronized int capacity()
void clear()
synchronized Object clone()
boolean contains(Object object)
synchronized boolean containsAll(Collection<?> collection)
synchronized void copyInto(Object[] elements)
synchronized E elementAt(int location)
Enumeration<E> elements()
synchronized void ensureCapacity(int minimumCapacity)
synchronized boolean equals(Object object)
synchronized E firstElement()
E get(int location)
synchronized int hashCode()
synchronized int indexOf(Object object, int location)
int indexOf(Object object)
synchronized void insertElementAt(E object, int location)
synchronized boolean isEmpty()
synchronized E lastElement()
synchronized int lastIndexOf(Object object, int location)
synchronized int lastIndexOf(Object object)
synchronized E remove(int location)
boolean remove(Object object)
synchronized boolean removeAll(Collection<?> collection)
synchronized void removeAllElements()
synchronized boolean removeElement(Object object)
synchronized void removeElementAt(int location)
synchronized boolean retainAll(Collection<?> collection)
synchronized E set(int location, E object)
synchronized void setElementAt(E object, int location)
synchronized void setSize(int length)
synchronized int size()
synchronized List<E> subList(int start, int end)
synchronized <T> T[] toArray(T[] contents)
synchronized Object[] toArray()
synchronized String toString()
synchronized void trimToSize()