JDK源码学习系列06-Vector
JDK源码学习系列06----Vector
Vector 继承了AbstractList，实现了List ,支持相关的添加、删除、修改、遍历等功能。
Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
JDK源码学习系列06----Vector
1.Vector简介
Vector的内部是数组实现的，它和ArrayList非常相似，最大的不同就是 Vector 是线程安全（同步）的。
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
Vector继承于AbstractList，实现了List, RandomAccess, Cloneable,java.io.Serializable这些接口。Vector 继承了AbstractList，实现了List ,支持相关的添加、删除、修改、遍历等功能。
Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
2.Vector的成员变量
protected Object[] elementData;//内部实现数组
protected int elementCount;//vector内容的实际长度
protected int capacityIncrement;//容量递增值
private static final long serialVersionUID = -2767605614048989439L;//序列id
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)//若容量递增值小于0，则抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];//elementData数组，容量为initialCapacity
this.capacityIncrement = capacityIncrement;//扩容时容量的递增值
}
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
public Vector() {// Vector的默认容量为10
this(10);
}
public Vector(Collection<? extends E> c) {//初始化一个包含集合的Vector
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.Vector的成员函数
很多成员函数都用synchronized关键字修饰了的，即表示是同步的，线程安全的。关于synchronized关键字，请见：java synchronized 关键字 。
public synchronized void copyInto(Object[] anArray) {//把Vector复制到anArray数组中
System.arraycopy(elementData, 0, anArray, 0, elementCount);//数组的复制都是用的System.arraycopy(),Arrays.copyof()的内部也是用的System.arraycopy().
}
public synchronized void trimToSize() {//把容量缩小到刚好等于vector的实际长度
modCount++;//!!线程安全的类的源码中也有统计结构变化次数的modCount
int oldCapacity = elementData.length;
if (elementCount < oldCapacity) {
elementData = Arrays.copyOf(elementData, elementCount);
}
}
public synchronized void ensureCapacity(int minCapacity) {//扩容，调用确认扩容帮助的方法
modCount++;
ensureCapacityHelper(minCapacity);
}
private void ensureCapacityHelper(int minCapacity) {//确认扩容的帮助方法
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {//<strong>①如果传入的参数大于原始容量：如果容量增幅值大于0，则增加容量增幅值；若容量增幅值小于0，则容量直接扩大两倍</strong>
Object[] oldData = elementData;
int newCapacity = (capacityIncrement > 0) ?
(oldCapacity + capacityIncrement) : (oldCapacity * 2);
if (newCapacity < minCapacity) {//<strong>②如果向上面那样增加后还是小于传入的参数：参数作为新的容量</strong>
newCapacity = minCapacity;
}
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
public synchronized void setSize(int newSize) {//设置容量值
modCount++;
if (newSize > elementCount) {//若容量值参数大于原始的容量，则扩容
ensureCapacityHelper(newSize);
} else {//若传入的容量值小于原始容量，即<strong>缩容：多出的后面部分全部置为null</strong>
for (int i = newSize ; i < elementCount ; i++) {
elementData[i] = null;
}
}
elementCount = newSize;//把传入的容量设置我新的容量
}
public synchronized int capacity() {//返回容量
return elementData.length;
}
public synchronized int size() {//返回实际长度
return elementCount;
}
public synchronized boolean isEmpty() {//判断是否为空
return elementCount == 0;
}
public Enumeration<E> elements() {//<span style="line-height: 1.5; font-family: 'Courier New'; white-space: pre-wrap; ">返回Vector中全部元素对应的Enumeration</span>
return new Enumeration<E>() {//<span style="line-height: 1.5; font-family: 'Courier New'; white-space: pre-wrap; ">通过匿名内部类实现Enumeration</span>
int count = 0;
public boolean hasMoreElements() {//是否存在下一元素
return count < elementCount;
}
public E nextElement() {//获取下一元素
synchronized (Vector.this) {
if (count < elementCount) {
return (E)elementData[count++];
}
}
throw new NoSuchElementException("Vector Enumeration");
}
};
}
public boolean contains(Object o) {//是否包含
return indexOf(o, 0) >= 0;
}
public int indexOf(Object o) {//定位索引
return indexOf(o, 0);
}
public synchronized int indexOf(Object o, int index) {
if (o == null) {//一定不要忽略了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 int lastIndexOf(Object o) {
return lastIndexOf(o, elementCount-1);
}
public synchronized int lastIndexOf(Object o, int index) {
if (index >= elementCount)//时刻注意边界
throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
if (o == null) {//不要忘了null!!!
for (int i = index; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = index; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
public synchronized E elementAt(int index) {//得到某个索引对应的值
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
}
return (E)elementData[index];//即数组下标对应的值，注意向下转型
}
public synchronized E firstElement() {//获取第一个元素
if (elementCount == 0) {//!!!!!!!!!!!特殊情况的考虑啊!!!!!!!!!!!!
throw new NoSuchElementException();//若vector为空则抛出异常
}
return (E)elementData[0];
}
public synchronized E lastElement() {
if (elementCount == 0) {
throw new NoSuchElementException();
}
return (E)elementData[elementCount - 1];
}
public synchronized void setElementAt(E obj, int index) {
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
elementData[index] = obj;
}
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;//需要移动的位于index后的元素个数
if (j > 0) {
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--;
elementData[elementCount] = null;//gc会自动回收掉最后一个空出来的位置
}
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位置移到从index+1,移动的长度为elementCount-index.即空出一个来插入元素
elementData[index] = obj;
elementCount++;
}
public synchronized void addElement(E obj) {//在vector尾部添加元素
modCount++;
ensureCapacityHelper(elementCount + 1);//添加元素时先扩容
elementData[elementCount++] = obj;
}
public synchronized boolean removeElement(Object obj) {//移除某个元素，先得到元素的索引在根据索引移除
modCount++;
int i = indexOf(obj);
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}
public synchronized void removeAllElements() {//移除所有，把每个元素都置为null
modCount++;
// Let gc do its work
for (int i = 0; i < elementCount; i++)
elementData[i] = null;
elementCount = 0;
}
public synchronized Object clone() {//克隆Vector
try {
Vector<E> v = (Vector<E>) super.clone();
v.elementData = Arrays.copyOf(elementData, elementCount);//将vector中的元素全部拷贝到v中
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
public synchronized Object[] toArray() {// 返回数组
return Arrays.copyOf(elementData, elementCount);
}
public synchronized <T> T[] toArray(T[] a) {
if (a.length < elementCount)//若a的长度小于vector的实际长度，则新建一个长度为elementCount的数组
return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
System.arraycopy(elementData, 0, a, 0, elementCount);
if (a.length > elementCount)//多出的置为null
a[elementCount] = null;
return a;
}
public synchronized E get(int index) {//根据索引得到元素
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return (E)elementData[index];
}
public synchronized E set(int index, E element) {//设置某索引处的值，返回旧值
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
Object oldValue = elementData[index];
elementData[index] = element;
return (E)oldValue;
}
public synchronized boolean add(E e) {//在尾部添加一元素，成功了才返回true
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
public boolean remove(Object o) {//根据值移除某一元素
return removeElement(o);
}
public void add(int index, E element) {
insertElementAt(element, index);
}
public synchronized E remove(int index) {//根据索引移除某一元素
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
Object 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 (E)oldValue;
}
public void clear() {//清空vector
removeAllElements();
}
public synchronized boolean containsAll(Collection<?> c) {
return super.containsAll(c);
}
public synchronized boolean addAll(Collection<? extends E> c) {//将集合添加到vector的尾部，先扩容再利用System.arraycopy()
modCount++;
Object[] a = c.toArray();//把集合先变成数组
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
System.arraycopy(a, 0, elementData, elementCount, numNew);
elementCount += numNew;
return numNew != 0;
}
public synchronized boolean removeAll(Collection<?> c) {
return super.removeAll(c);
}
public synchronized boolean retainAll(Collection<?> c) {
return super.retainAll(c);
}
public synchronized boolean addAll(int index, Collection<? extends E> c) {//从某一索引处添加集合
modCount++;
if (index < 0 || index > elementCount)
throw new ArrayIndexOutOfBoundsException(index);
Object[] a = c.toArray();//把集合先变成数组
int numNew = a.length;
ensureCapacityHelper(elementCount + numNew);
int numMoved = elementCount - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);//移动原数组
System.arraycopy(a, 0, elementData, index, numNew);
elementCount += numNew;
return numNew != 0;
}
public synchronized int hashCode() {//计算hash值
return super.hashCode();
}
public synchronized String toString() {
return super.toString();
}
public synchronized List<E> subList(int fromIndex, int toIndex) {//截取从fromIndex到toIndex，不包含toIndex
return Collections.synchronizedList(super.subList(fromIndex, toIndex),
this);
}
protected synchronized void removeRange(int fromIndex, int toIndex) {//利用System.arraycopy()来移动数组达到移除元素的作用
modCount++;
int numMoved = elementCount - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// Let gc do its work
int newElementCount = elementCount - (toIndex-fromIndex);
while (elementCount != newElementCount)
elementData[--elementCount] = null;
}
private synchronized void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException
{
s.defaultWriteObject();
}
a.Vector的内部是数组实现的。
b.Vector是线程安全（同步）的。
c.Vector默认长度为10,扩容时需要参考容量增幅值，若容量增幅值大于0，则扩容为 原容量+容量增幅值；若容量增幅值小于 0，则扩容为 2*原容量。若根据容量增幅值扩容后 还是小于传入的新容量参数值，则容量扩为传入的新参数。