ArrayList 源码解析

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 数组第一个 add 时候的长度，默认是 10，；
    private static final int DEFAULT_CAPACITY = 10;
  
    //表示当前数组的长度；
 		private int size;
  
  	// 保存集合数据的数组
    transient Object[] elementData; // non-private to simplify nested class access
  
    //  这个集合修改结构的次数
    protected transient int modCount = 0;
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 默认构造器， 直接初始化， 默认大小为空
public ArrayList() {
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 使用已存在的集合初始化ArrayList
public ArrayList(Collection<? extends E> c) {
  // elementData 是保存数组的容器，默认为 null
  elementData = c.toArray();
  // 给定的集合 c 有值
  if ((size = elementData.length) != 0) {
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    // 如果给定的集合不是 Object 类型， 我们会转成 Object 
    if (elementData.getClass() != Object[].class)
      elementData = Arrays.copyOf(elementData, size, Object[].class);
  } else {
    // 给定集合无值，则默认空数组
    this.elementData = EMPTY_ELEMENTDATA;
  }
}

// 指定 ArrayList 初始长度
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 boolean add(E e) {
  // 确保数组长度足够, size 是数组的长度
  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) {
  if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    return Math.max(DEFAULT_CAPACITY, minCapacity);
  }
  return minCapacity;
}

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // 如果期望的最小容量小于目前数组的长度，就需要扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

// 扩容数组，扩容至原先容量的 1.5 倍
private void grow(int minCapacity) {
  // 原先的容量
  int oldCapacity = elementData.length;
  // 新容量
  int newCapacity = oldCapacity + (oldCapacity >> 1);
  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) {
  if (minCapacity < 0) 
    throw new OutOfMemoryError();
  return (minCapacity > MAX_ARRAY_SIZE) ?
    Integer.MAX_VALUE :
  MAX_ARRAY_SIZE;
}

public boolean remove(Object o) {
  if (o == null) {
    for (int index = 0; index < size; index++)
      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;
  if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);
  elementData[--size] = null; // clear to let GC do its work
}

int cursor;// 迭代过程中，下一个元素的位置，默认从 0 开始。
int lastRet = -1; // 新增场景：表示上一次迭代过程中，索引的位置；删除场景：为 -1。
int expectedModCount = modCount;// expectedModCount 表示迭代过程中，期望的版本号；modCount 表示数组实际的版本号。

 public boolean hasNext() {
   return cursor != size;
 }

 public E next() {
   //迭代过程中，判断版本号有无被修改，有被修改，抛 ConcurrentModificationException 异常
   checkForComodification();
   //本次迭代过程中，元素的索引位置
   int i = cursor;
   if (i >= size)
     throw new NoSuchElementException();
   Object[] elementData = ArrayList.this.elementData;
   if (i >= elementData.length)
     hrow new ConcurrentModificationException();
   // 下一次迭代时，元素的位置，为下一次迭代做准备
   cursor = i + 1;
   return (E) elementData[lastRet = i];
 }

// 版本号比较
final void checkForComodification() {
  if (modCount != expectedModCount)
    throw new ConcurrentModificationException();
}

public void remove() {
  	// 如果上一次操作时，数组的位置已经小于 0 了，说明数组已经被删除完了
    if (lastRet < 0)
        throw new IllegalStateException();
     //迭代过程中，判断版本号有无被修改，有被修改，抛 ConcurrentModificationException 异常
    checkForComodification();

    try {
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
      	// -1 表示元素已经被删除，这里也防止重复删除
        lastRet = -1;
      // 删除元素时 modCount 的值已经发生变化，在此赋值给 expectedModCount
    	// 这样下次迭代时，两者的值是一致的了
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

public void add(int index, E element) {
    synchronized (mutex) {list.add(index, element);}
}