JDK源码之Vector

下文带/**/为源码注释//为个人注释。源代码使用这个颜色

Vector可以设置增量的集合
add(e)扩容增量值得使用
add(idx,e)末尾追加还是任意插入？
set(idx,ele)替换数组元素
get(idx)根据数组下标获取
remove(idx)使用本地方法复制数组
remove(obj)删除第一个匹配的元素
setSize()扩容还是截断？
ArrayList和Vector的区别

Vector可以设置增量的集合

/*存储矢量分量的数组缓冲区。向量的容量是这个数组缓冲区的长度，并且至少足够大来包含向量的所有元素。*/

//存放集合元素的数组

protected Object[] elementData;

/*当矢量的大小大于其容量时，其容量自动增加的数量。如果容量增量小于或等于零，则每次需要增长时，向量的容量就增加一倍。*/

//应该是集合扩容时用到的，它的作用还有待考

protected int capacityIncrement;

//集合的长度，默认是0

protected int elementCount;

/*构造一个空向量，以便其内部数据数组的大小为10，其标准容量增量为零。*/

public Vector() {
this(10);
}

/*构造一个具有指定初始容量且容量增量为零的空向量。*/

public Vector(int initialCapacity) {
this(initialCapacity, 0);
}

/*构造一个具有指定初始容量和容量增量的空向量。*/

public Vector(int initialCapacity, int capacityIncrement) {
super();

//如果初始容量小于0报错
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);

//创建一个容量10的数组
this.elementData = new Object[initialCapacity];

//增量为0
this.capacityIncrement = capacityIncrement;
}

add(e)扩容增量值得使用

/*将指定的元素追加到此向量的末尾。*/

//加锁了

public synchronized boolean add(E e) {
modCount++;

//第一次添加传入参数为elementCount=0 (0+1)

//第二次添加传入参数为elementCount=1 (1+1)

//第三次添加传入参数为elementCount=2 (2+1)

//第四次添加传入参数为elementCount=3 (3+1)

//第五次添加传入参数为elementCount=4 (4+1)

//第六次添加传入参数为elementCount=5 (5+1)

//第七次添加传入参数为elementCount=6 (6+1)

//第八次添加传入参数为elementCount=7 (7+1)

//第九次添加传入参数为elementCount=8 (8+1)

//第十次添加传入参数为elementCount=9 (9+1)

//第十一次添加传入参数为elementCount=10 (10+1)
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}

//集合错误长度这个值是 -2147483649

public static final int MAX_VALUE = 0x7fffffff;

//集合最大长度

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/*这实现了ensureCapacity的非同步语义。该类中的同步方法可以在内部调用此方法以确保容量，而不会产生额外同步的开销。*/

private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code

//判断是否扩容，初始容器是10第11次添加才会触发扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

//第11次添加这里传入的值是11

private void grow(int minCapacity) {
// overflow-conscious code

//elementData.length=10
int oldCapacity = elementData.length;

//capacityIncrement>0 false

//newCapactiy=10+10,在这能看出来，如果自己设置了增量

//那么每次扩容则按照增量值为标准

int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);

//什么情况下这里才能<0如果没有传递增量，newCapctiy都是oldCapacity的两倍

//如果传递了，不能是0也不能是负数就算是1那么11-11也不<0
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;

//这里表示如果新的容量大于了阈值这个阈值是Integer.MAX_VALUE - 8;

//到这里newCapacity肯定是正数也就是只有大于MAX_ARRAY_SIZE才是>0
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);

//最后拷贝数组，ArrayList也是这个方法拷贝的，这次进去看看
elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {

//这个条件不会满足
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();

//如果大于了则是负数其实也是错误的，否则使用最大值MAX_ARRAY_SIZE
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}

//这是Arrays的方法

public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}

//三个参数是原数组，扩容长度，数组类型

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")

//判断数组类型是不是Object如果是直接创建一个Object类型的数组

//如果不是则创建一个指定类型的数组，newInstance后边也是本地方法

//最后调用本地方法System.arraycopy。关于这个方法的参数在ArrayList

//中聊过这里不展开说了
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}

add(idx,e)末尾追加还是任意插入？

/*

将指定元素插入到此向量的指定位置。将元素当前的位置(如果有的话)

和后续的元素向右移动(在它们的索引中添加一个)。

*/

public void add(int index, E element) {
insertElementAt(element, index);
}

/*

将指定的对象作为组件插入到这个向量中指定的{@code索引}处。

这个向量中索引大于或等于指定的{@code索引}的每个组件向上

移动，使其索引值比之前的值大1。

*/

//方法加锁了，参数是要添加得元素和下标

public synchronized void insertElementAt(E obj, int index) {

//计数器
modCount++;

//在这里限定了如果下标大于当前集合总长度则报错。

//也就是说index最多只能是集合size，推几行数据

//A:elementCount=0,index可以=0

//B:elementCount=1,index可以=0,1

//C:elementCount=2,index可以=0,1,2

//D:elementCount=3,index可以=0,1,2,3

//E:elementCount=4,index可以=0,1,2,3,4

//F:elementCount=5,index可以=0,1,2,3,4,5

//如果index==elementCount说明是往数组末尾追加元素

//如果index<elementCount是什么情况呢？
if (index > elementCount) {
throw new ArrayIndexOutOfBoundsException(index
+ " > " + elementCount);
}

//这个方法控制数组是否扩容,假设我们数组当前不满足10则不会触发第一次扩容

//跳过这个方法继续看
ensureCapacityHelper(elementCount + 1);

//arraycopy的参数是:源数组,从这个位置开始复制,目标数组,从这个位置开始放,复制几个元素

System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
elementData[index] = obj;
elementCount++;
}

//如果是A情况实参为(设元素类型是Integer):[0,0,0,0,0,0,0,0,0,0],0,[0,0,0,0,0,0,0,0,0,0],1,0

//结果其实是没有对数组进行任何操作的，因为要复制的元素为0个。

//最后执行elementData[0]=obj其实就是在数组0的位置放了元素，这个结果相当于追加

//如果是B情况则可以有两个index分别是0，1先来看1的。

//[8,0,0,0,0,0,0,0,0,0],1,[8,0,0,0,0,0,0,0,0,0],2,0

//在这种情况下还是没有任何操作。最终最后执行elementData[0]=obj

//来看B情况的index=0

//[8,0,0,0,0,0,0,0,0,0],0,[8,0,0,0,0,0,0,0,0,0],1,1

//结果是[8,8,0,0,0,0,0,0,0,0]

//然后在执行elementData[1]=obj，把下标0的替换掉[9,8,0,0,0,0,0,0,0,0]

//这样的结果就是index位置插入原有的往后挪。

//最后看一个C情况它可选的index是0，1，2

如果是2则[8,9,0,0,0,0,0,0,0,0]，2，[8,9,0,0,0,0,0,0,0,0]，3，0

只要最后一个实参是0则表示要诺的元素就是0个，则没有任何改变。

最后执行elementData[0]=obj结果是[8,9,7,0,0,0,0,0,0,0]，追加

如果是1则[8,9,0,0,0,0,0,0,0,0]，1，[8,9,0,0,0,0,0,0,0,0]，2，1

结果为：[8,9,9,0,0,0,0,0,0,0]执行elementData[1]=obj结果为[8,7,9,0,0,0,0,0,0,0]后挪

如果是0则[8,9,0,0,0,0,0,0,0,0]，0，[8,9,0,0,0,0,0,0,0,0]，1，2

结果是：[8,8,9,0,0,0,0,0,0,0]执行elementData[0]=obj结果为[7,8,9,0,0,0,0,0,0,0]后挪

set(idx,ele)替换数组元素

/*将向量中指定位置的元素替换为指定元素。*/

//加锁了

public synchronized E set(int index, E element) {

//index不能超过当前集合的长度，也就规定了只能是替换
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);

//根据下标获取old值

E oldValue = elementData(index);

//在下标位置设置新值
elementData[index] = element;

//返回old
return oldValue;
}

get(idx)根据数组下标获取

/**返回向量中指定位置的元素。**/

//加锁了

public synchronized E get(int index) {

//index必须小于集合size
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);

//返回

return elementData(index);
}

remove(idx)使用本地方法复制数组

/*移除向量中指定位置的元素。将后面的元素向左移动(从它们的索引中减去1)。返回从向量中删除的元素。*/

public synchronized E remove(int index) {

//计数器
modCount++;

//index大于等于size抛出异常
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);
elementData[--elementCount] = null; // Let gc do its work

return oldValue;
}

设当前集合为[a,b,c,d,e]要删除a则index=0

numMoved=5-0-1=4

arraycopy的参数列表为[a,b,c,d,e]，1，[a,b,c,d,e]，0，4

结果为[b,c,d,e,e]，最后elementData[- -5]=null结果为[b,c,d,e,null]

设当前集合为[a,b,c,d,e]要删除b则index=1

numMoved=5-1-1=3

arraycopy的参数列表为[a,b,c,d,e]，2，[a,b,c,d,e]，1，3

结果为[a,c,d,e,e]，最后elementData[- -5]=null结果为[a,c,d,e,null]

设当前集合为[a,b,c,d,e]要删除e则index=4

numMoved=5-4-1=0

arraycopy的参数列表为[a,b,c,d,e]，5，[a,b,c,d,e]，4，0

最后一个参数为0表示不移动则这个方法无意义。

最后执行elementData[- -5]=null结果为[a,b,c,d,null]

remove(obj)删除第一个匹配的元素

/*删除此向量中第一次出现的指定元素。如果向量不包含该元素，则该元素不变*/

public boolean remove(Object o) {
return removeElement(o);
}

/*

从此向量中删除参数的第一个(索引最低的)出现。如果在这个向量中找到了对象，

那么向量中索引大于或等于该对象索引的每个分量都向下移动，使其索引值小于它之前的值。

*/

public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj);
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}

public int indexOf(Object o) {
return indexOf(o, 0);
}

/*

返回指定元素在此向量中第一次出现的索引，从{@code index}向前搜索，或者如果没有找到该元素，返回-1。

*/

//查询元素的下标

public synchronized int indexOf(Object o, int index) {

//如果是null则循环判断null,从0开始
if (o == null) {
for (int i = index ; i < elementCount ; i++)
if (elementData[i]==null)
return i;
} else {

//如果不是null则循环调用元素的equals方法,从0开始
for (int i = index ; i < elementCount ; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}

/*

删除指定索引处的组件。在这个向量中，索引大于或等于指定的{@code索引}的

每个组件都向下移动，使其索引值比之前的值小1。这个向量的大小被减少了{@code 1}。

*/

public synchronized void removeElementAt(int index) {

//计数器
modCount++;

//下标越界
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}

//下标小于0
else if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}

//下边的逻辑就跟remove(idx)差不多了，调用arraycopy()
int j = elementCount - index - 1;
if (j > 0) {
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--;
elementData[elementCount] = null; /* to let gc do its work */
}

setSize()扩容还是截断？

/*

设置这个向量的大小。如果新的大小大于当前大小，新的{@code null}项将被添加到向量的末尾。

如果新大小小于当前大小，索引{@code newSize}和更大的所有组件将被丢弃。

*/

//加锁了

public synchronized void setSize(int newSize) {
modCount++;

//如果新的size大于原来的，则直接选择扩容，扩容的方式上边有解释
if (newSize > elementCount) {
ensureCapacityHelper(newSize);
} else {

//从新的size开始往后所有的值都置为null

for (int i = newSize ; i < elementCount ; i++) {
elementData[i] = null;
}
}

//重新赋值size
elementCount = newSize;
}

ArrayList和Vector的区别

1 容量初始化时机

ArrayList如果使用无参构造器，则集合的容量在第一次添加时扩容为10

Vector如果使用无参构造，Vector会默认设置一个10的容量

2 扩容因子

ArrayList不能手动设置扩容因子，Vector可以通过构造参数设置扩容因子

3 扩容算法

ArrayList扩容的算法是 newsize=oldsize+oldsize/2

Vector扩容的算法是 newsize=oldsize+oldsize或者newsize=oldsize+扩容因子

4 同步和非同步

ArrayList的增删改查均没有加锁

Vector的增删改查均加的有 synchronized

5 更改size

ArrayList不能手动更改size

Vector可以手动更改size