private int size; // 實(shí)際元素個(gè)數(shù)
transient Object[] elementData; //真正保存元素的數(shù)組
private static final int DEFAULT_CAPACITY = 10;//默認(rèn)的初始容量大小

//1、無(wú)參數(shù)直接初始化，數(shù)組大小為空
public ArrayList() {
 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//2、指定初始數(shù)據(jù)初始化
public ArrayList(Collection<? extends E> c){
 //elementData是保存數(shù)組的容器，默認(rèn)為null
 elementData=c.toArray();
 //如果給定的集合（c)數(shù)據(jù)有值
 if((size=elementData.length)!=0){
  	//c.toArray might(incorrectly)not return Object[](see 6260652)
  	//如果集合元素類型不是Object類型，我們會(huì)轉(zhuǎn)成Object
	 if(elementData.getClass()!=Object[].class){
	  elementData=Arrays.copyOf(elementData,size,Object].class);
	 }
 	}else{
 	//給定集合（c)無(wú)值，則默認(rèn)空數(shù)組
 	this.elementData=EMPTY_ELEMENTDATA
 	}
}
//3、指定初始容量
public ArrayList(int initialCapacity) {
	//指定的初始容量大于0，將elementData初始化為指定大小的數(shù)組
 if (initialCapacity > 0) {
  this.elementData = new Object[initialCapacity];
 } else if (initialCapacity == 0) {
 	//否則初始化成一個(gè)空數(shù)組
  this.elementData = EMPTY_ELEMENTDATA;
 }
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final Object[] EMPTY_ELEMENTDATA = {};

public boolean add(E e) {
	//確保數(shù)組大小是否足夠，不夠執(zhí)行擴(kuò)容，size為當(dāng)前數(shù)組元素個(gè)數(shù)，判斷size+1是因?yàn)楹竺孢€要size++
 ensureCapacityInternal(size + 1); //1
 elementData[size++] = e;//2
 return true;
}

private void ensureCapacityInternal(int minCapacity) {
	//先調(diào)用calculateCapacity計(jì)算容量
 	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
 //如果當(dāng)前數(shù)組還是個(gè)空數(shù)組，也就是他用過(guò)無(wú)參構(gòu)造去初始化的
 //那么直接返回DEFAULT_CAPACITY，即10
 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  return Math.max(DEFAULT_CAPACITY, minCapacity);
 }
 return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
 modCount++;

 // 如果當(dāng)前容量已經(jīng)大于當(dāng)前數(shù)組的長(zhǎng)度了，說(shuō)明需要去擴(kuò)容了
 if (minCapacity - elementData.length > 0)
  //擴(kuò)容
  grow(minCapacity);
}

private void grow(int minCapacity){
 int oldCapacity = elementData.length;
 //oldCapacity>>1是把oldCapacity除以2的意思
 int newCapacity=oldCapacity+(oldCapacity>>1);
 //如果擴(kuò)容后的值<我們的期望值，擴(kuò)容后的值就等于我們的期望值
 if(newCapacity-minCapacity<0)
 newCapacity = minCapacity;
 //如果擴(kuò)容后的值>jvm所能分配的數(shù)組的最大值，那么就用Integer的最大值
 if(newCapacity-MAX_ARRAY_SIZE>0)
 elementData=Arrays.copyOf(elementData,newCapacity);
}

/**
*@param src 被拷貝的數(shù)組
*@param srcPos 從數(shù)組那里開(kāi)始
*@param dest 目標(biāo)數(shù)組
*@param destPos從目標(biāo)數(shù)組那個(gè)索引位置開(kāi)始拷貝
*@param length 拷貝的長(zhǎng)度
*此方法是沒(méi)有返回值的，通過(guò)dest的引用進(jìn)行傳值
*/
public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);

public boolean remove(Object o) {
 //如果要?jiǎng)h除的值是null,刪除第一個(gè)是null的值
 if(o==null){
 for(int index=0;index<size;index++)
  if(elementData[index]==null){
  fastRemove(index)
  return true;
  }
 }else{
 //如果要?jiǎng)h除的值不為null,找到第一個(gè)和要?jiǎng)h除的值相等的刪除
 for(int index=0;index<size;index++)
  //這里是根據(jù) equals來(lái)判斷值相等的，相等后再根據(jù)索引位置進(jìn)行刪除
  //所以根據(jù)對(duì)象刪除時(shí)，一般來(lái)說(shuō)，如果你確定要?jiǎng)h除的是某一類的業(yè)務(wù)對(duì)象，則需要重寫equals
  if(o.equals(elementData[index]){
  fastRemove(index)
  return true;
  }
 }
 return false
}

private void fastRemove(int index){
 //記錄數(shù)組的結(jié)構(gòu)要發(fā)生變動(dòng)了
 nodCount++;
 //numMoved表示刪除index位置的元素后，需要從index后移動(dòng)多少個(gè)元素到前面去
 //減1的原因，是因?yàn)閟ize從1開(kāi)始算起，index從0開(kāi)始算起
 int numMoved=size-index-1;
 if(numMoved>0)
 //從index+1位置開(kāi)始被拷貝，拷貝的起始位置是index,長(zhǎng)度是numMoved
 System.arraycopy(elementData, index+1, elementData, index, numMoved);
 //數(shù)組最后一個(gè)位置賦值null,幫助GC(沒(méi)有引用則自動(dòng)回收了)
 elementData[--size] = null;
}