一、成员变量
private static final int DEFAULT_CAPACITY = 10; // 默认容量，在未指定初始容量时，默认容量为10private static final Object[] EMPTY_ELEMENTDATA = {}; // 除自动扩容场景外使用此空数组private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 在扩容如果elementData指向此数组，elementData会初始化为容量为10的数组transient Object[] elementData; // 数据存储数组private int size; // 元素个数 二、关于初始化
ArrayList提供了三种构造器：
1. 无参构造器：
public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // 无参构造器，默认初始容量为10，在第一次add时加载} 2. 指定容量构造器：
public ArrayList(int initialCapacity) { if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; // 指定了初始容量为0时，指向空数组 } else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); }} 3. 指定集合构造器
public ArrayList(Collection 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; }} 三、关于扩容
1. 在调用add()方法是会调用ensureCapacityInternal(int minCapacity)告诉List我最少需要多少容量
private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 如果elementData指向上文说的空数组，则将最少需要10个容量 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); // 判断是否需要扩容} 2. ensureExplicitCapacit(int minCapacity)方法会判断到底需不需要扩容
private void ensureExplicitCapacity(int minCapacity) { modCount++; // 每次可能需要扩容的时候，必然会操作集合，所以在这里同意进行modCount++ // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); // 如果需要的最小容量 大于 当前elementData.length，则扩容} 3. grow(int minCapacity)会进行扩容操作，默认按照原容量的1.5倍扩容
private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; // 老容量 int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量默认等于 oldCapacity + oldCapacity / 2 if (newCapacity - minCapacity < 0) // 如果计算的新容量 小于 需要的最小容量，则本次按照指定的minCapacity扩容 newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0) // 如果新容量 大于 数组最大容量（Integer.Max_Value - 8）,进行大容量处理 newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity);} 4. 对于minCapacity超过MAX_ARRAY_SIZE的情况做一些操作
private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // 超过最大限制，抛出内存溢出错误 throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? // 否则返回最大数组长度（Integer.MAX_VALUE - 8） Integer.MAX_VALUE : MAX_ARRAY_SIZE;} 5. 为什么数组最大容量是 Integer.MAX_VALUE - 8？
// 因为有些VM会给数组加一些头部信息，如果指定再大的值可能会导致内存溢出
四、关于迭代
ArrayList内部实现Iterator接口，通过iterator()获取迭代器
1. 迭代器成员变量
int cursor; // 下一个迭代的元素地址int lastRet = -1; // 当前迭代的元素地址，调用next()方法时会等于cursorint expectedModCount = modCount; // 用于判断是否有并发操作问题
2. 使用hasNext()方法，判断是否还有未迭代的元素
public boolean hasNext() { return cursor != size;} 3. 使用next()方法获取下一个元素
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]; // 获取当前元素} 4. 如果需要删除当前元素，使用remove()方法删除，保证迭代器正常使用
public void remove() { if (lastRet < 0) // lastRet < 0说明当前没有元素 throw new IllegalStateException(); checkForComodification(); // 检查并发操作问题 try { ArrayList.this.remove(lastRet); // 按照下标删除 cursor = lastRet; // cursor - 1 lastRet = -1; // 当前元素指向 -1 expectedModCount = modCount; // 保证操作正常 } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); }} 5. checkForComodification()检查是否有并发操作
final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException();}