ArrayList概述

1.ArrayList是基于數組實現的，是一個動態數組，與Java的數組相比，它的容量可以自動增長擴容。
2.ArrayList實現了RandomAccess（支持隨機快速訪問，通過序列號訪問元素內容），實現了Cloneable（可以被克?。?，實現了Serializable（可以被序列化）。
3.ArrayList不是線程安全的，最好在單線程情況下使用，多線程的情況下考慮用concurrent并發包下面的CopyOnWriteArrayList類或者Vector類，或者通過Collections.synchronizedList(list)函數返回一個線程安全的ArraList類

構造函數

 public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)  // 如果initialCapacity>0就給定一個 initialCapacity大小的數組
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
 }

 private static final Object[] EMPTY_ELEMENTDATA = {};
  
 public ArrayList() {
      super();
      this.elementData = EMPTY_ELEMENTDATA;  // 給定一個空數組
 }

  // 構造一個包含指定元素的list，這些元素是按照C的迭代器返回的順序排列的
  public ArrayList(Collection<? extends E> paramCollection)
  {
    this.elementData = paramCollection.toArray(); //轉換
    if ((this.size = this.elementData.length) != 0)
    {
      if (this.elementData.getClass() != [Ljava.lang.Object.class) { // 不是Object類型就強制轉換為Object類型
        this.elementData = Arrays.copyOf(this.elementData, this.size, [Ljava.lang.Object.class); 
      }
    }
    else {
      this.elementData = EMPTY_ELEMENTDATA;
    }
  }

添加

 public boolean add(E e) {
        //  增加一個元素首先得保證底層數組不越界
        ensureCapacityInternal(size + 1);  // 增加modCount!!
        elementData[size++] = e;
        return true;
 }

 private void ensureCapacityInternal(int minCapacity) {
        //  之前使用的是ArrayList()作為構造函數的話，第一次擴展把空數組擴展成size=10的數組
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
  }
// 數組容量檢查，不夠時則進行擴容
 private void ensureExplicitCapacity(int minCapacity) {
        //這個變量記錄了對ArrayList修改的次數(Fail-Fast 就是檢測的這個變量)
        modCount++;
        // overflow-conscious code
        //  當前數組沒有更多容量了，則需要動態擴展
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
  }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //  即newCapacity =1.5倍oldCapacity，所以ArrayList每次動態擴展是1.5倍的擴展 
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // ArrayList不適合Add很多的場景，每當底層數組擴容后需要把所有的元素從老數組copy到新數組
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

添加(指定下標)

   public void add(int index, E element) {
        rangeCheckForAdd(index); // 判斷輸入的下標是否越界

        ensureCapacityInternal(size + 1);  // 增加 modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index); // 需要把指定位置后面的所有元素都往后移動一個位置，所以也是比較低效的。
        elementData[index] = element; // 指定位置存放元素
        size++;
    }

 private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

讀取

 public E get(int index) {
        rangeCheck(index);  //  判斷索引是否越界
        return elementData(index); // 返回指定索引的值
 }

/**
  *檢查給定的索引是否在范圍內。如果沒有，就拋出一個適當的
  *運行時異常。該方法不檢查索引是否為
  *否定:在數組訪問之前，它總是被立即使用，
  *拋出ArrayIndexOutOfBoundsException如果指數是負的。
*/
 private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

修改

public E set(int index, E element) {
        rangeCheck(index);   // 判斷索引是否越界
        E oldValue = elementData(index); // 取得舊的值
        elementData[index] = element; // 設為新的值
        return oldValue; // 返回舊的值 
  }

刪除

 public E remove(int index) {
        rangeCheck(index);  //  判斷索引是否越界

        modCount++; 
        E oldValue = elementData(index); 

        int numMoved = size - index - 1;
        if (numMoved > 0)   //  把index后面的元素整體向前移動，可以看出這步是非常耗資源的
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
         // 放棄對最后一個元素的引用，讓GC能回收掉它
        elementData[--size] = null; // clear to let GC do its work

        return oldValue; // 返回被刪除的那個元素
    }

 public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {  //  刪除數組中所有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)  //  把index后面的元素整體向前移動，可以看出這步是非常耗資源的
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
         // 放棄對最后一個元素的引用，讓GC能回收掉它
        elementData[--size] = null; // clear to let GC do its work
    }