1.add(Object obj)
//构造器Vector()
Vector v1 = new Vector();
v1.add(1);
v1.add(2);
v1.add(3);
v1.add(4);
v1.add(5);
v1.add(6);
v1.add(7);
v1.add(8);
v1.add(9);
v1.add(10);
v1.add(11);
//无参构造器,初始化Vector,数组长度为10
public Vector() {
this(10);
}
//一个参数的构造函数
public Vector(int initialCapacity) {
//initialCapacity = 10
this(initialCapacity, 0);
}
//两个参数的构造函数
public Vector(int initialCapacity, int capacityIncrement) {
//initialCapacity = 10 capacityIncrement = 0
super();
if (initialCapacity < 0)
//如果initialCapacity < 0,会抛出IllegalArgumentException异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
//元素为int类型,所以进行装箱
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
}
}
//此add方法加上了synchronized,所以为线程安全的
public synchronized boolean add(E e) {
modCount++;//计数器
//elementCount = 0
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
//minCapacity = 1
//elementData.length = 10
//elementData = [null, null, null, null, null, null, null, null, null, null]
//所以前十个元素不进行数组扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
....
//第十一个元素开始
//元素为int类型,所以进行装箱
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
}
}
public synchronized boolean add(E e) {
modCount++;
//elementCount = 10
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
private void ensureCapacityHelper(int minCapacity) {
//minCapacity = 11
//elementData.length = 10
//成立,进行扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
//minCapacity = 11
//elementData.length = 10
//oldCapacity = 10
int oldCapacity = elementData.length;
//capacityIncrement = 0
//所以 newCapacity = 20
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
//不成立。
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//不成立.
//private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//成立的话,数组会溢出
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//实现数组的复制,把新的数组替换点旧的.数组得到扩容.变为原来的2倍
elementData = Arrays.copyOf(elementData, newCapacity);
}
//综上分析:当初始化Vector时,底层数组的长度为10,当向里面添加第一个元素时,数组的长度变还为10,当
//数组长度大于10时,数组会进行扩容.经分析,每次扩容新的长度为原来的2倍 所以第二次扩容为20,第三次为40
//到此,ArrayList的add(Object) 源码分析完
2.get(int index) 得到下标为index位置上的元素
//加上了synchronized,所以为线程安全的
public synchronized E get(int index) {
//判断下标是否大于元素长度,否则排除数组越界异常
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
return elementData(index);
}
//返回下标为index的元素
E elementData(int index) {
return (E) elementData[index];
}
3.remove(int index),返回值为Object类型
public E remove(int index) {
modCount++;//计数器
//index:传入要删除元素的位置,假设下标为2,即index=2
//检查index是否越界
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
//得到下标为index的元素,值为oldValue
E oldValue = elementData(index);
//此时数组的长度为11,size=11,index=2,所以numMoved=8
int numMoved = size - index - 1;
//arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
//从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束。
//第一个elementData:原数组
//第二个elementData:目标数组
//源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。
//public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//此时最后的一个元素设为nul,这是数组的长度就减1了
elementData[--size] = null; // clear to let GC do its work
//返回删除的元素
return oldValue;
}
private void rangeCheck(int index) {
//当index大于数组的长度时,会抛出数组下标越界异常.
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
4.remove(Object obj),当遇到要删除的对象为int类型时,要把该int类型的值进行装箱,变为Integer类型
public Integer(int value) {
this.value = value;
}
public boolean remove(Object o) {
return removeElement(o);
}
//加上synchronized,线程安全的
public synchronized boolean removeElement(Object obj) {
modCount++;
//记录obj在第几个位置
int i = indexOf(obj);
//如果大于0
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}
public synchronized void removeElementAt(int index) {
modCount++;
//如果要删除的下标大于数组长度,则抛出数组下标越界异常
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " +
elementCount);
}
//如果要删除的下标小于0,则抛出数组下标越界异常
else if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}
//arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
//从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束。
//第一个elementData:原数组
//第二个elementData:目标数组
//源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。
//public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
int j = elementCount - index - 1;
if (j > 0) {
System.arraycopy(elementData, index + 1, elementData, index, j);
}
//最后一个位置上的元素设置为null
elementCount--;
elementData[elementCount] = null; /* to let gc do its work */
}