1 使用方法
Vector和ArrayList类似，是数组队列，可以实现容量的动态增长。Vector类继承了AbstractList抽象类并且实现了List、RandomAccess，Cloneable以及java.io.Serializable接口。
public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable
AbstractList类继承了AbstractCollection类并实现了List接口。
实现RandomAccess接口使Vector拥有随机访问的能力，即通过下表索引访问数组元素。
实现Cloneable接口重写了接口定义的clone()方法，Vector可以使用clone()复制数组。
实现 java.io.Serializable接口使Vector支持序列化。
Vector和ArrayList的最大不同是Vector是线程安全的而ArrayList不是。Vector几乎所有的方法都使用synchronized关键字是来保证线程安全使它的性能比不上ArrayList。
Vector和ArrayList不同还体现在动态增长的策略上。ArrayList的基本增长策略是oldCapacity*1.5+1，如果还不够则容量为实际需要容量；Vector的基本增长策略是oldCapacity+设定好的增长幅度，如果没设定则新容量增长为oldCapacity*2，如果还不够则为实际需要的容量。
现在很少使用Vector。
1.1 方法介绍
ArrayList提供了增加、删除、判空等操作，具体提供的方法如下：
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) //将数组中的元素复制到element中
synchronized E elementAt(int location) //获取location位置的元素
Enumeration<E> elements() //返回一个包含数组元素的枚举
synchronized void ensureCapacity(int minimumCapacity) //增加数组空间
synchronized boolean equals(Object object) //比较元素
synchronized E firstElement() //获取第一个元素
E get(int location) //获取location下标的元素
synchronized int hashCode() //获取对象的hashCode
synchronized int indexOf(Object object, int location) //从location开始第一次出现object的位置
int indexOf(Object object) //第一次出现object的位置
synchronized void insertElementAt(E object, int location) //在location位置插入object
synchronized boolean isEmpty() //判空
synchronized E lastElement() //获取最后元素
synchronized int lastIndexOf(Object object, int location) //location之前最后出现object的位置
synchronized int lastIndexOf(Object object) //最后一次出现object的位置
synchronized E remove(int location) //删除location位置的元素
boolean remove(Object object) //删除第一次出现的object
synchronized boolean removeAll(Collection<?> collection) //删除collection出现的所有元素
synchronized void removeAllElements() //将所有元素置为null
synchronized boolean removeElement(Object object) //同remove
synchronized void removeElementAt(int location) //同remove
synchronized boolean retainAll(Collection<?> collection) //删除除了collection中元素之外的所有元素
synchronized E set(int location, E object) //设置location位置的元素为object
synchronized void setElementAt(E object, int location) //同set
synchronized void setSize(int length) //设置数组大小,若length大于实际长度则空余元素置为null
synchronized int size() //获取实际大小
synchronized List<E> subList(int start, int end) //获取子串
synchronized <T> T[] toArray(T[] contents) //转换成数组
synchronized Object[] toArray() //
synchronized void trimToSize() //将数组容量改为实际数组大小1.2 使用示例
public class TestVector {
public void testVector() {
Vector vector = new Vector<>(10); //申请一个初始容量大小为10的Vector
for (int i = 0; i < 5; i++) { //初始化元素为
vector.add(i);
}
System.out.println("此时数组实际大小为: " + vector.size());
printVector("Vector此时元素有", vector);
vector.set(4,44); //设置第5个元素为44
vector.add(2,22); //在第3个元素位置增加22
printVector("Vector此时元素有", vector);
vector.add(2);
System.out.println("第1次出现2的位置为: " + vector.indexOf(2));
vector.remove(2); //删除第3个元素
vector.remove((Object)44); //删除第一次出现的44
printVector("Vector此时元素有", vector);
int size = vector.size();
for (int i = size; i < size + 6; i++) {
vector.add(i);
}
printVector("Vector此时元素有", vector);
System.out.println("Vector此时大小为: " + vector.size());
System.out.println("Vector此时的容量为: " + vector.capacity()); //原有容量为10, 超出容量后新容量为2倍
//转为数组
Integer [] arr = (Integer[]) vector.toArray(new Integer[0]);
System.out.print("遍历数组结果: ");
for (Integer i:arr) {
System.out.print(i + " ");
}
}
/** * 打印Vector * @param vector */
protected void printVector(String comment, List vector) {
System.out.print(comment + ": ");
for (int i = 0; i < vector.size(); i++) {
System.out.print(vector.get(i) + " ");
}
System.out.println("");
}
}运行结果如下：
此时数组实际大小为: 5
Vector此时元素有: 0 1 2 3 4
Vector此时元素有: 0 1 22 2 3 44
第1次出现2的位置为: 3
Vector此时元素有: 0 1 2 3 2
Vector此时元素有: 0 1 2 3 2 5 6 7 8 9 10
Vector此时大小为: 11
Vector此时的容量为: 20
遍历数组结果: 0 1 2 3 2 5 6 7 8 9 102 源码分析
2.1构造函数
/** * 构造一个初始容量为initialCapacity,动态增长为capacityIncrement的Vector * @param initialCapacity * @param capacityIncrement */
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
/** * 初始容量为initialCapacity,动态增长容量为0 * @param initialCapacity */
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
/** * 初始容量为10,动态增长为0 */
public Vector() {
this(10);
}
/** * 申请一个Vector,并用c初始化 * @param c */
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) //bug 6260652,toArray可能不会返回Object数组,这是重新复制
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}2.2 add方法
/** * 添加e到Vector末尾 * @param e * @return */
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1); //增加容量
elementData[elementCount++] = e;
return true;
}
/** * 在index位置插入element * @param index * @param element */
public void add(int index, E element) {
insertElementAt(element, index);
}
/** * 在index位置插入obj * @param obj * @param index */
public synchronized void insertElementAt(E obj, int index) {
modCount++;
if (index > elementCount) {
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}
ensureCapacityHelper(elementCount + 1);
//将elementData元素从index开始，复制到elementData的index+1开始，总共 elementCount - index长度，即后移1位
System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
}2.3 set方法
/** * 将index位置的元素置为element * @param index * @param element * @return */
public synchronized E set(int index, E element) {
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}2.4 remove方法
/** * 删除index位置的元素 * @param index * @return */
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) //不是删除最后一个元素,则所有元素前移1位
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--elementCount] = null; // Let gc do its work
return oldValue;
}2.5 toArray方法
/** * 返回T类型的数组,参数不能是基本类型 * @param a * @param <T> * @return */
public synchronized <T> T[] toArray(T[] a) {
if (a.length < elementCount) //a长度小于Vector已有的元素个数,重新申请一个数组
return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
System.arraycopy(elementData, 0, a, 0, elementCount); //将元素复制到a中
if (a.length > elementCount)
a[elementCount] = null;
return a;
}参考：
[1] http://www.cnblogs.com/skywang12345/p/3308833.html
[2] http://blog.csdn.net/ns_code/article/details/35793865
[3] http://blog.csdn.net/mazhimazh/article/details/19568867
