ArrayList的底層實現原理

ArrayList源碼分析

1、java.util.ArrayList<E> : List 接口的大小可變數組的實現類

• ArrayList 內部基於 數組 存儲 各個元素。
• 所謂大小可變數組，是指當 數組容量不足以存放新的元素時，創建新數組，並將原數組中的內容復制過來。

2、ArrayList底層實現原理

• 構造方法源碼分析

  //對象數組：ArrayList的底層數據結構，transient表示該字段不進行序列化操作
  transient Object[] elementData;
  //實例化一個空數組
  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  //實例化一個空數組
  private static final Object[] EMPTY_ELEMENTDATA = {};
  
  /**
   *指定初始容量的有參構造
   */
  public ArrayList(int initialCapacity) {
           //如果初始容量大於0就，對象數組就指向到一個新的數組，大小為所指定的大小
          if (initialCapacity > 0) {
              this.elementData = new Object[initialCapacity];
          } else if (initialCapacity == 0) {
              //如果大於0就指向一個空數組
              this.elementData = EMPTY_ELEMENTDATA;
          } else {
              throw new IllegalArgumentException("Illegal Capacity: "+
                                                 initialCapacity);
          }
  }
  /**
  * 無參構造
  */
  public ArrayList() {
           //對象數組就指向到一個空數組
          this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  }

  ArrayList基於數組實現，構造方法有有參構造和無參構造如果指定了初始容量且大於0就將對象數組指定到一個新的數組，大小為所指定的大小。如果調用無參構造就將對象數組指定到一個空的數組。

• 添加方法源碼分析

  //elementData中已存放的元素的個數，注意：不是elementData的容量
  private int size;
  //elementData的默認容量為10
  private static final int DEFAULT_CAPACITY = 10;
  //對象數組：ArrayList的底層數據結構，transient表示該字段不進行序列化操作
  transient Object[] elementData;
  //實例化一個空數組
  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  //實例化一個空數組
  private static final Object[] EMPTY_ELEMENTDATA = {};
  
  protected transient int modCount = 0;
  
  @Native public static final int   MAX_VALUE = 0x7fffffff;
  
  private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  
  /**
   * 向elementData末尾中添加元素
   */
  public boolean add(E e) {
         //確保對象數組elementData有足夠的容量，可以將新加入的元素e加進去
          ensureCapacityInternal(size + 1);  
          //加入新元素e，size加1
          elementData[size++] = e;
          return true;
  }
  
  // minCapacity = seize+1，即表示執行完添加操作后，數組中的元素個數 
  private void ensureCapacityInternal(int minCapacity) {
          //判斷是否是空數組
          if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              //用最小容量和10進行比較，取最大值賦值給最小容量
              minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
          }
  
          ensureExplicitCapacity(minCapacity);
   }
  
  /**
   *確保數組的容量足夠存放新加入的元素，若不夠，要擴容
   */
  private void ensureExplicitCapacity(int minCapacity) {
          modCount++;
          //如果數組個數minCapacity （size+1）大於數組長度就需要進行擴容
          if (minCapacity - elementData.length > 0)
              grow(minCapacity);
  }
  
  private void grow(int minCapacity) {
          int oldCapacity = elementData.length;
          // 將舊的數組容量增加為原來的1.5倍作為新的容量
          int newCapacity = oldCapacity + (oldCapacity >> 1);             
         //如果新的容量小於數組個數，將數組個數賦值給新容量
          if (newCapacity - minCapacity < 0)
              newCapacity = minCapacity;
         // 如果新的容量大於最大容量，就根據數組個數來決定新的容量大小
          if (newCapacity - MAX_ARRAY_SIZE > 0)
              newCapacity = hugeCapacity(minCapacity);
          // 根據新的容量，將數組拷貝到新的數組並賦值給數組
          elementData = Arrays.copyOf(elementData, newCapacity);
  }
  
  private static int hugeCapacity(int minCapacity) {
         // 如果數組個數小於0拋出OutOfMemoryError異常
          if (minCapacity < 0) // overflow
              throw new OutOfMemoryError();       
         // 如果最數組個數大於最大容量 就返回最大值，否則返回最大容量
          return (minCapacity > MAX_ARRAY_SIZE) ?
              Integer.MAX_VALUE :
              MAX_ARRAY_SIZE;
  }
  /**
   * 向elementData指定位置添加元素
   */
  public void add(int index, E element) {
         //指定位置檢查
          rangeCheckForAdd(index);
          // 擴容檢查
          ensureCapacityInternal(size + 1);  // Increments modCount!!
          //通過拷貝使數組內位置為 index 到 （size-1）的元素往后移動一位
          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));
  }
  /**
   * @param      src      原數組.
   * @param      srcPos   原數組的起始位置.
   * @param      dest     目標數組.
   * @param      destPos  目標數組的起始位置.
   * @param      length   拷貝長度.
   */
  public static native void arraycopy(Object src,  int  srcPos,
                                          Object dest, int destPos,
                                          int length);

  ArrayList在無參的add方法中，每次插入新的元素時，先判斷是否需要擴容，判斷數組是否為空，為空則建默認的容量10賦值給minCapacity，判斷是否要擴容，第一次添加，數組的size是10，之后添加元素時，在ensureExplicitCapacity方法中判斷數組元素個數即size+1（形參minCapacity）是否超過數組長度，超過則需要進行擴容操作，擴容是將舊的容量擴大到1.5倍，然后將數組拷貝到新的數組完成擴容操作。最后將元素添加，並size+1。ArrayList在指定位置添加元素時，是先檢查指定位置是否在數組范圍內，即數組中元素個數是1，則index得小於或者低於1。然后通過拷貝使數組內位置為 index 到 （size-1）的元素往后移動一位，騰出位置之后放入元素，數組個數加一。

• 刪除方法源碼分析

  public E remove(int index) {
         //指定位置檢查
          rangeCheck(index);
          modCount++;       
         //保留要刪除的值
          E oldValue = elementData(index);
         //要移動元素個數
          int numMoved = size - index - 1;
          if (numMoved > 0)
          //通過拷貝使數組內位置為 index+1到 （size-1）的元素往前移動一位
              System.arraycopy(elementData, index+1, elementData, index,
                               numMoved);
          //清除末尾元素讓GC回收
          elementData[--size] = null; // clear to let GC do its work
          //返回刪除的值
          return oldValue;
      }

  刪除指定位置的元素，先對index進行檢查，在將要刪除的值保留，計算出需要移動元素個數，再通過拷貝使數組內位置為 index+1到 （size-1）的元素往前移動一位，最后將末尾元素清理讓GC回收返回刪除值。由於List接口繼承了Collection，因此ArrayList還有一個來自Collection接口定義的刪除對象boolean remove( Object o ) ，而ArrayList自定義的remove方法是T remove(int index)刪除的是下標位置的對象並返回值。

參考博客鏈接

https://my.oschina.net/90888/blog/1625416

轉載請於明顯處標明出處

https://www.cnblogs.com/AmyZheng/p/9427140.html