JDK源码深入学习之Vector

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()

参考博文：
1.Java 集合系列06之 Vector详细介绍(源码解析)和使用示例