Java ArrayList使用總結

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

//1、無參數直接初始化，數組大小為空
public ArrayList() {
 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//2、指定初始數據初始化
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{
 	//給定集合（c)無值，則默認空數組
 	this.elementData=EMPTY_ELEMENTDATA
 	}
}
//3、指定初始容量
public ArrayList(int initialCapacity) {
	//指定的初始容量大於0，將elementData初始化為指定大小的數組
 if (initialCapacity > 0) {
  this.elementData = new Object[initialCapacity];
 } else if (initialCapacity == 0) {
 	//否則初始化成一個空數組
  this.elementData = EMPTY_ELEMENTDATA;
 }
}

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

public boolean add(E e) {
	//確保數組大小是否足夠，不夠執行擴容，size為當前數組元素個數，判斷size+1是因為後面還要size++
 ensureCapacityInternal(size + 1); //1
 elementData[size++] = e;//2
 return true;
}

private void ensureCapacityInternal(int minCapacity) {
	//先調用calculateCapacity計算容量
 	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
 //如果當前數組還是個空數組，也就是他用過無參構造去初始化的
 //那麼直接返回DEFAULT_CAPACITY，即10
 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);
}

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所能分配的數組的最大值，那麼就用Integer的最大值
 if(newCapacity-MAX_ARRAY_SIZE>0)
 elementData=Arrays.copyOf(elementData,newCapacity);
}

/**
*@param src 被拷貝的數組
*@param srcPos 從數組那裡開始
*@param dest 目標數組
*@param destPos從目標數組那個索引位置開始拷貝
*@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++)
  //這裡是根據 equals來判斷值相等的，相等後再根據索引位置進行刪除
  //所以根據對象刪除時，一般來說，如果你確定要刪除的是某一類的業務對象，則需要重寫equals
  if(o.equals(elementData[index]){
  fastRemove(index)
  return true;
  }
 }
 return false
}

private void fastRemove(int index){
 //記錄數組的結構要發生變動瞭
 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);
 //數組最後一個位置賦值null,幫助GC(沒有引用則自動回收瞭)
 elementData[--size] = null;
}