java ArrayList實現原理

1. ArrayList  概述
ArrayList是List接口的可變數組的實現。 實現了所有可選列表操作， 並允許包括 null 在內的所有元素。除了實
現 List 接口外，此類還提供一些方法來操作內部用來存儲列表的數組的大小。每個 ArrayList 實例都有一個容量，該
容量是指用來存儲列表元素的數組的大小。它總是至少等於列表的大小。隨着向 ArrayList 中不斷添加元素，其容量
也自動增長。 自動增長會帶來數據向新數組的重新拷貝，因此，如果可預知數據量的多少，可在構造 ArrayList 時指
定其容量。 在添加大量元素前， 應用程序也可以使用 ensureCapacity 操作來增加 ArrayList實例的容量，這可以減少
遞增式再分配的數量。注意，此實現不是同步的。如果多個線程同時訪問一個 ArrayList 實例，而其中至少一個線程
從結構上修改了列表，那麼它必須保持外部同步。相對比 的， ，Vector 是 是 線程 安全 的 ， 其中 涉及 線程 安全 
的 方法 皆 被 同步。
2. ArrayList  的實現
對於 ArrayList 而言，它實現 List 接口、底層使用數組保存所有元素。其操作基本上是對數組的操作。下面我們來分析 ArrayList 的源代碼：
1)  底層使用數組實現
Java  代碼 
private transient Object[] elementData;
2)  構造 器 ：
ArrayList 提供了三種方式的構造器，可以構造一個默認初始容量爲 10 的空列表(這個是java6和java6以前的版本的，
java7和以後的版本默認是構造一個空的數組)、構造一個指定初始容量的空列表以及構造一個包含指定 collection 的
元素的列表，這些元素按照該 collection 的迭代器返回它們的順序排列的。
Java  代碼
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

    public ArrayList() {

        super();
        this.elementData = EMPTY_ELEMENTDATA;

    }

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
3)  存儲：
ArrayList 提供了 set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection<? extends 
E> c)、addAll(int index, Collection<? extends E> c)這些添加元素的方法。下面我們一一講解：
      // 用指定的元素替代此列表中指定位置上的元素，並返回以前位於該位置上的元素。
     public E set(int index, E element) {
      rangeCheck(index);
              E oldValue = elementData(index);
      elementData[index] = element;
      return oldValue;
     }
     // 將指定的元素添加到此列表的尾部
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //將指定的元素插入此列表中的指定位置。
    // 如果當前位置有元素， 則向右移動當前位於該位置的元素以及所有後續元素 （將其索引加 1） 。
    public void add(int index, E element) {
        rangeCheckForAdd(index);
  // 如果數組長度不足，將進行擴容。
        ensureCapacityInternal(size + 1);  // Increments modCount!!
// 將 elementData 中從 Index 位置開始、長度爲 size-index 的元素，
// 拷貝到從下標爲 index+1 位置開始的新的 elementData 數組中。
// 即將當前位於該位置的元素以及所有後續元素右移一個位置。
        System.arraycopy(elementData, index, elementData, index + 1,size - index);
        elementData[index] = element;
        size++;
    }
    // 按照指定 collection 的迭代器所返回的元素順序，將該 collection 中的所有元素添加到此列表的尾部。
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }
    // 從指定的位置開始，將指定 collection 中的所有元素插入到此列表中。
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }
4)  讀取：
    // 返回此列表中指定位置上的元素。
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
5)  刪除：
ArrayList 提供了根據下標或者指定對象兩種方式的刪除功能。如下：
   // 移除此列表中指定位置上的元素。
   public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        elementData[--size] = null; // clear to let GC do its work
        return oldValue;
    }
    // 移除此列表中首次出現的指定元素 （如果存在） 。 這是應爲ArrayList中允許存放重複的元素。
    public boolean remove(Object o) {
    // 由於 ArrayList 中允許存放 null，因此下面通過兩種情況來分別處理。
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
    // 類似 remove(int index)，移除列表中指定位置上的元素。
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
6)  調整數組容量：
  從上面介紹的向 ArrayList 中存儲元素的代碼中， 我們看到， 每當向數組中添加元素時，都要去檢查添加後元素的
個數是否會超出當前數組的長度，如果超出，數組將會進行擴容，以滿足添加數據的需求。數組擴容通過一個公開的
方法 ensureCapacity(int minCapacity)來實現。在實際添加大量元素前，我也可以使用 ensureCapacity 來手動增加 
ArrayList 實例的容量，以減少遞增式再分配的數量。
  private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
  private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
 ArrayList  還給我們提供了將底層數組的容量調整爲當前列表保存的實際元素的大小的功能。它可以通過 trimToSize 方法來實現。代碼如下：
public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }