ArrayList只写add方法了，其他的方法感兴趣的自己看一下，都比较简单。
构造函数
public ArrayList(int initialCapacity) {
// 如果初始容量大于0，则创建一个initialCapacity大小的数组
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 初始容量等于0，则用初始数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
// 无参构造函数，用默认数组，并且默认的的容量是10
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection<? extends E> c) {
// elementData被赋值为元素数组
elementData = c.toArray();
// 元素个数(size)被赋值为elementData的长度
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;
}
}
添加元素
需要的常量
// 默认数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 默认容量
private static final int DEFAULT_CAPACITY = 10;
// 数组的最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
public boolean add(E e) {
// 调整容量
ensureCapacityInternal(size + 1); // Increments modCount!!
// 调整完容量加入元素
elementData[size++] = e;
return true;
}
// 调整容量
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算添加元素所需要的最小容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果是第一次add，则返回默认容量和当前minCapacity的最大值
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 若不是第一次add，则返回minCapacity
return minCapacity;
}
// 调整容量
private void ensureExplicitCapacity(int minCapacity) {
// 修改次数自增
modCount++;
// 若添加元素所需的容量比当前数组长度小了，则扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 真正扩容
private void grow(int minCapacity) {
// 原容量
int oldCapacity = elementData.length;
// 新容量是原容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 新容量还是不够，那么新容量就等于minCapacity
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 新容量溢出了
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 拷贝一个新数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
// 容量溢出处理
private static int hugeCapacity(int minCapacity) {
// 已经超出int范围了，抛OutOfMemoryError
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
// 没超出返回新容量
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
minCapacity代表添加元素所需要的容量，等于原容量+添加的元素个数
Q&A
Q：最大数组容量MAX_ARRAY_SIZE为啥是 Integer.MAX_VALUE - 8？
A：数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节。
最后一点需要注意的
java.util包下的集合为啥都不支持增强for或者迭代器迭代修改集合？
答案在ArrayList的迭代器代码中找。
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
Itr() {}
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
// 注意
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
// 注意
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
可以看到每次调用迭代器的next方法获取下一个元素的时候，总是会执行checkForComodification，这个方法会对比modCount和expectedModCount是否一致，如果不一致则抛出ConcurrentModificationException。而add、remove、clear等方法都会修改modCount的值。
调用迭代的remove方法则不会有这个问题，因为每次remove都会更新expectedModCount的值
