//默認初始化容量
private static final int DEFAULT_CAPACITY = 10;

//空對象數(shù)組
private static final Object[] EMPTY_ELEMENTDATA = {};

//對象數(shù)組
private transient Object[] elementData;

//集合元素個數(shù)
private int size;

//傳入初始容量的構(gòu)造方法
public ArrayList(int initialCapacity) {
  super();
  if (initialCapacity < 0) {
    throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
  }
  //新建指定容量的Object類型數(shù)組
  this.elementData = new Object[initialCapacity];
}

//不帶參數(shù)的構(gòu)造方法
public ArrayList() {
  super();
  //將空的數(shù)組實例傳給elementData
  this.elementData = EMPTY_ELEMENTDATA;
}

//傳入外部集合的構(gòu)造方法
public ArrayList(Collection<? extends E> c) {
  //持有傳入集合的內(nèi)部數(shù)組的引用
  elementData = c.toArray();
  //更新集合元素個數(shù)大小
  size = elementData.length;
  //判斷引用的數(shù)組類型, 并將引用轉(zhuǎn)換成Object數(shù)組引用
  if (elementData.getClass() != Object[].class) {
    elementData = Arrays.copyOf(elementData, size, Object[].class);
  }
}

//增(添加)
public boolean add(E e) {
  //添加前先檢查是否需要拓展數(shù)組, 此時數(shù)組長度最小為size+1
  ensureCapacityInternal(size + 1);
  //將元素添加到數(shù)組末尾
  elementData[size++] = e;
  return true;
}


//增(插入)
public void add(int index, E element) {
  //插入位置范圍檢查
  rangeCheckForAdd(index);
  //檢查是否需要擴容
  ensureCapacityInternal(size + 1);
  //挪動插入位置后面的元素
  System.arraycopy(elementData, index, elementData, index + 1, size - index);
  //在要插入的位置賦上新值
  elementData[index] = element;
  size++;
}

//刪
public E remove(int index) {
  //index不能大于size
  rangeCheck(index);
  modCount++;
  E oldValue = elementData(index);
  int numMoved = size - index - 1;
  if (numMoved > 0) {
    //將index后面的元素向前挪動一位
    System.arraycopy(elementData, index+1, elementData, index, numMoved);
  }
  //置空引用
  elementData[--size] = null;
  return oldValue;
}

//改
public E set(int index, E element) {
  //index不能大于size
  rangeCheck(index);
  E oldValue = elementData(index);
  //替換成新元素
  elementData[index] = element;
  return oldValue;
}

//查
public E get(int index) {
  //index不能大于size
  rangeCheck(index);
  //返回指定位置元素
  return elementData(index);
}

private void ensureCapacityInternal(int minCapacity) {
  //如果此時還是空數(shù)組
  if (elementData == EMPTY_ELEMENTDATA) {
    //和默認容量比較, 取較大值
    minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
  }
  //數(shù)組已經(jīng)初始化過就執(zhí)行這一步
  ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
  modCount++;
  //如果最小容量大于數(shù)組長度就擴增數(shù)組
  if (minCapacity - elementData.length > 0) {
    grow(minCapacity);
  }
}

//集合最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

//增加數(shù)組長度
private void grow(int minCapacity) {
  //獲取數(shù)組原先的容量
  int oldCapacity = elementData.length;
  //新數(shù)組的容量, 在原來的基礎(chǔ)上增加一半
  int newCapacity = oldCapacity + (oldCapacity >> 1);
  //檢驗新的容量是否小于最小容量
  if (newCapacity - minCapacity < 0) {
    newCapacity = minCapacity;
  }
  //檢驗新的容量是否超過最大數(shù)組容量
  if (newCapacity - MAX_ARRAY_SIZE > 0) {
    newCapacity = hugeCapacity(minCapacity);
  }
  //拷貝原來的數(shù)組到新數(shù)組
  elementData = Arrays.copyOf(elementData, newCapacity);
}