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

//1、無參數(shù)直接初始化，數(shù)組大小為空
public ArrayList() {
 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//2、指定初始數(shù)據(jù)初始化
public ArrayList(Collection<? extends E> c){
 //elementData是保存數(shù)組的容器，默認為null
 elementData=c.toArray();
 //如果給定的集合（c)數(shù)據(jù)有值
 if((size=elementData.length)!=0){
  	//c.toArray might(incorrectly)not return Object[](see 6260652)
  	//如果集合元素類型不是Object類型，我們會轉(zhuǎn)成Object
	 if(elementData.getClass()!=Object[].class){
	  elementData=Arrays.copyOf(elementData,size,Object].class);
	 }
 	}else{
 	//給定集合（c)無值，則默認空數(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) {
 	//否則初始化成一個空數(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í)行擴容，size為當前數(shù)組元素個數(shù)，判斷size+1是因為后面還要size++
 ensureCapacityInternal(size + 1); //1
 elementData[size++] = e;//2
 return true;
}

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

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

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

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

/**
*@param src 被拷貝的數(shù)組
*@param srcPos 從數(shù)組那里開始
*@param dest 目標數(shù)組
*@param destPos從目標數(shù)組那個索引位置開始拷貝
*@param length 拷貝的長度
*此方法是沒有返回值的，通過dest的引用進行傳值
*/
public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);

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

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