成员变量
private static final int DEFAULT_CAPACITY = 10;//数组初始化长度为10
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //初始化指向地址
transient Object[] elementData; // non-private to simplify nested class access
private int size; //存储的元素个数,size<DEFAULT_CAPACITY
构造方法
/**
* 无参构造方法,默认空数组
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 指定数组容量大小的构造方法
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 参数是集合的构造方法
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
插入第一个元素过程
add()方法
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 判断并扩容,第一次加入,size==0
elementData[size++] = e;
return true;
}
/**
* ensureCapacityInternal方法
*/
private void ensureCapacityInternal(int minCapacity) {//minCapacity=1
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* calculateCapacity方法
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//第一次添加元素,elementData为空,成立
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity); //DEFAULT_CAPACITY为10,返回10
}
return minCapacity;
}
/**
* ensureExplicitCapacity方法
*/
private void ensureExplicitCapacity(int minCapacity) {//minCapacity等于10
modCount++;
if (minCapacity - elementData.length > 0)//数组为空,成立
grow(minCapacity);
}
/**
* grow方法
*/
private void grow(int minCapacity) {//传入10
int oldCapacity = elementData.length;//数组为空长度为0
int newCapacity = oldCapacity + (oldCapacity >> 1);//仍然为0
if (newCapacity - minCapacity < 0) //成立
newCapacity = minCapacity;//把10 赋值给新容量
if (newCapacity - MAX_ARRAY_SIZE > 0) //数组太大,异常处理,无视
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);//开辟一个新数组,长度为10
}
插入第一个元素的时候,开辟了一个长度为10的数组。属于延迟加载,添加元素时才分配空间10
array.copyOf方法的使用在另一个文章中
插入第n个元素,1<n<=10
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 参数为n
elementData[size++] = e;
return true;
}
/**
* ensureCapacityInternal方法
*/
private void ensureCapacityInternal(int minCapacity) {//参数为 n
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* calculateCapacity方法
* 不是第一次插入,elementData = 10
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //不是第一次加入,不成立
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;//返回n
}
/**
* ensureExplicitCapacity方法
*/
private void ensureExplicitCapacity(int minCapacity) {//minCapacity等于 n
modCount++;
if (minCapacity - elementData.length > 0)//n - 10 <0 所以不成立,不扩容
grow(minCapacity);
}
插入第11个元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 传入11
elementData[size++] = e;
return true;
}
/**
* ensureCapacityInternal方法
*/
private void ensureCapacityInternal(int minCapacity) {//参数为 11
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* calculateCapacity方法
* 不是第一次插入,elementData = 10
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //不是第一次加入,不成立
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;//返回 11
}
/**
* ensureExplicitCapacity方法
*/
private void ensureExplicitCapacity(int minCapacity) {//minCapacity等于 11
modCount++;
if (minCapacity - elementData.length > 0)//11 - 10 >0
grow(minCapacity);//进行扩容
}
/**
* grow方法
*/
private void grow(int minCapacity) {//传入11
int oldCapacity = elementData.length;//数组长度为 10
int newCapacity = oldCapacity + (oldCapacity >> 1);//值为 15
if (newCapacity - minCapacity < 0) //不成立
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //数组太大,异常处理,无视
newCapacity = hugeCapacity(minCapacity);
//开辟一个新数组,长度为15,复制源数据
elementData = Arrays.copyOf(elementData, newCapacity);
}
参考博客,有需要改进的可以留言