1.add(Object obj)
ArrayList list1 = new ArrayList();
list1.add("a");
list1.add(2);
list1.add(3);
list1.add(4);
list1.add(5);
list1.add(6);
list1.add(7);
list1.add(8);
list1.add(9);
list1.add(10);
list1.add(11);
System.out.println(list1);
public boolean add(E e) {//
//size为int类型的,初值为默认类型.所以此时size的值为0
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//此时minCapacity=1
//elementData和DEFAULTCAPACITY_EMPTY_ELEMENTDATA都为初值,所以相等
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//DEFAULT_CAPACITY:值为10,
//minCapacity:值为1
//DEFAULT_CAPACITY: private static final int DEFAULT_CAPACITY = 10;
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//传入的值 minCapacity=10,
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//位计数器,没有实质的作用
//elementData.length=0.
//minCapacity=10
//minCapacity - elementData.length > 0成立,
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//minCapacity=10
private void grow(int minCapacity) {
//elementData.length = 0;故 oldCapacity=0
int oldCapacity = elementData.length;
//newCapacity值也为0
int newCapacity = oldCapacity + (oldCapacity >> 1);
// newCapacity - minCapacity = -10 < 0成立,所以newCapacity = 10;
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//newCapacity - MAX_ARRAY_SIZE > 0不成立.若newCapacity - MAX_ARRAY_SIZE > 0成立,会内存溢出
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//newCapacity = 10,所以此时的elementData长度为10,数组的长度为10,此时的elementData内的是个元素都为null
elementData = Arrays.copyOf(elementData, newCapacity);
//这里的方法就是数组扩容.此时数组的长度变为10,之后在往上返回
}
//此时,add的方法源码分析完毕,这是会把“a”这个元素添加到数组中,之后进行分析再添加一个元素
//添加第二个元素时
//若添加的元素的int类型,会把int类型装箱,变为Integer类型
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
public boolean add(E e) {
//此时size为1
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//此时minCapacity=2
//此时elementData=[a, null, null, null, null, null, null, null, null, null]
//DEFAULTCAPACITY_EMPTY_ELEMENTDATA 还是为0个长度
//所以不成立
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//此时minCapacity=2
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
//minCapacity = 2,elementData.length > 0不成立,所以,数组的不扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);//数组的扩容
}
//当数组的元素个数小于等于10时,数组都不扩容
.
.
.
.
.
.
//当添加到11个元素时
//第11个元素还未int类型,所以进行装箱
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
//添加元素
public boolean add(E e) {
//此时size为10
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//minCapacity = 11
//elementData = [a, 2, 3, 4, 5, 6, 7, 8, 9, 10]
//DEFAULTCAPACITY_EMPTY_ELEMENTDATA = []
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
//minCapacity:11
//elementData.length = 10
//此时成立,执行数组的扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//数组扩容
private void grow(int minCapacity) {
//minCapacity = 11
//elementData.length = 10
int oldCapacity = elementData.length;
//oldCapacity >> 1: 右移1位,所以为5
//newCapacity = 15
int newCapacity = oldCapacity + (oldCapacity >> 1);
//newCapacity = 15 minCapacity = 11,不成立
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//不成立
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//此时新的数组的长度为15,数组长度变大
elementData = Arrays.copyOf(elementData, newCapacity);
}
//新数组的长度为15
//综上分析:当初始化ArrayList时,底层数组的长度为0《当向里面添加第一个元素时,数组的长度变为10,当
//数组长度大于10时,数组会进行扩容.经分析,每次扩容新的长度为原来的1.5倍 所以第二次扩容为15,第三次为22
//到此,ArrayList的add(Object) 源码分析完
2.get(index)
//构造器ArrayList()
public ArrayList() {
//1.elementData是一个Object[]的数组.
//2.private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};是一个空的数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
ArrayList list1 = new ArrayList();
list1.add("a");
list1.add(2);
list1.add(3);
list1.add(4);
list1.add(5);
list1.add(6);
list1.add(7);
list1.add(8);
list1.add(9);
list1.add(10);
list1.add(11);
Object value = list1.get(2);
System.out.println(value);
//1.get(index)
public E get(int index) {
//检查下标是否越界,否则会抛出数组下标越界异常
rangeCheck(index);
//返回下标为index的元素
return elementData(index);
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//返回下标为index的元素
E elementData(int index) {
return (E) elementData[index];
}
3..remove(index),返回值为Object类型
//构造器ArrayList()
public ArrayList() {
//1.elementData是一个Object[]的数组.
//2.private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};是一个空的数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//1.remove(index),返回值为Object类型
public E remove(int index) {
//index:传入要删除元素的位置,假设下标为2,即index=2
//检查index是否越界
rangeCheck(index);
modCount++;//计数器
//得到下标为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类型
//构造器ArrayList()
public ArrayList() {
//1.elementData是一个Object[]的数组.
//2.private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};是一个空的数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
ArrayList list1 = new ArrayList();
list1.add("a");
list1.add(2);
list1.add(3);
list1.add(4);
list1.add(5);
list1.add(6);
list1.add(7);
list1.add(8);
list1.add(9);
list1.add(10);
list1.add(11);
Object value = list1.remove(new Integer(2));
System.out.println(value);
//1.remove(Object obj),当遇到要删除的对象为int类型时,
//要把该int类型的值进行装箱,变为Integer类型
public boolean remove(Object o) {
//当传入的对象为null值是.
if (o == null) {
//遍历数组elementData
for (int index = 0; index < size; index++)
//如果遍历到值为null的时
if (elementData[index] == null) {
//进行删除操作
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
//删除操作
private void fastRemove(int index) {
modCount++;
//要移动的长度
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);
//最后一个位置上的元素设置为null
elementData[--size] = null; // clear to let GC do its work
}