Java-基礎-ArrayList

張鐵牛發表於2021-10-27
Java

1. 簡介

ArrayList 實現了 List 介面，其底層基於陣列實現容量大小動態可變。既然是陣列，那麼元素存放一定是有序的，並允許包括 null 在內的所有元素。

每個 ArrayList 例項都有一個容量（capacity）。該容量是指用來儲存列表元素的陣列的大小。它總是至少等於列表的大小。隨著向 ArrayList 中不斷新增元素，其容量也自動增長。

2. 初始化

// Test::main() 構造一個List例項
List<Integer> list1 = new ArrayList<>();

ArrayList 初始化原始碼如下：

// 空陣列
private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 儲存元素的緩衝陣列（存放值的陣列）
transient Object[] elementData; 

// 集合中包含的元素數量
private int size;

// 構造一個空的陣列
public ArrayList() {
  this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// 構造一個指定長度的陣列
public ArrayList(int initialCapacity) {
  if (initialCapacity > 0) {
    this.elementData = new Object[initialCapacity];
  } else if (initialCapacity == 0) {
    this.elementData = EMPTY_ELEMENTDATA;
  } else {
    throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
  }
}

// 構造一個包含指定集合元素的列表，按照集合的迭代器返回的順序
public ArrayList(Collection<? extends E> c) {
  Object[] a = c.toArray();
  if ((size = a.length) != 0) {
    if (c.getClass() == ArrayList.class) {
      elementData = a;
    } else {
      elementData = Arrays.copyOf(a, size, Object[].class);
    }
  } else {
    // replace with empty array.
    elementData = EMPTY_ELEMENTDATA;
  }
}

看了原始碼之後感覺ArrayList的初始化好簡單，有如下幾種方式：

  1. 構造一個空陣列。
  2. 構造一個指定長度的陣列。
  3. 將傳入的集合轉成陣列，並指向 elementData。

既然建立ArrayList例項是通過new出來的，那我們不妨看一看list1例項在jvm中是如何分佈的。

ArrayList.class 被載入時，static修飾的變數，會被載入到方法區。

當我們再建立一個ArrayList例項list2，會是如何分佈呢？

通過資料在JVM中的分佈，我們可以瞭解到作者設計的巧妙之處，當我們建立多個list例項時，其實底層都是指向快取在方法區的Object[]陣列。

3. 自動擴容

3.1 第一次新增元素

在看自動擴容之前，我們先了解下當我們第一次給list中新增元素的時候，底層都幹了些什麼事。

private int size;

// ArrayList::add()
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    // 給指定的索引元素賦值 沒啥好說的
    elementData[size++] = e;
    return true;
}

我們繼續看下ensureCapacityInternal方法。

// 預設的容量長度
private static final int DEFAULT_CAPACITY = 10;

private void ensureCapacityInternal(int minCapacity) {
  // 當第一次add的時候 minCapacity = 1，elementData = {}
  ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 計算容量值
private static int calculateCapacity(Object[] elementData, int minCapacity) {
  if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
    // 當 elementData = {}時，獲取最大值，即返回10
    return Math.max(DEFAULT_CAPACITY, minCapacity);
  }
  return minCapacity;
}

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

  // 10 - 0 > 0
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}

// 真正的擴容方法
private void grow(int minCapacity) {
  // 舊容量 = 0
  int oldCapacity = elementData.length;
  // 新容量 = 0 + 0 / 2 即：新容量 = 0。右移一位相當於除以2
  int newCapacity = oldCapacity + (oldCapacity >> 1);
  if (newCapacity - minCapacity < 0)
    // 0 - 10 < 0。 newCapacity = 10
    newCapacity = minCapacity;
  if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);
  // 將elementData的值 copy 到 新容量的陣列中
  elementData = Arrays.copyOf(elementData, newCapacity);
}

copy過程如下：

// Arrays::copyOf()
public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
  @SuppressWarnings("unchecked")
  T[] copy = ((Object)newType == (Object)Object[].class)
    // 建立一個新長度的陣列
    ? (T[]) new Object[newLength]
    : (T[]) Array.newInstance(newType.getComponentType(), newLength);
  // native方法，實現值copy
  System.arraycopy(original, 0, copy, 0,
                   Math.min(original.length, newLength));
  return copy;
}

從原始碼中得知，當我們建立一個空的list，並且第一次給list中新增元素的時候：

  1. 建立一個長度為DEFAULT_CAPACITY = 10的陣列
  2. 將elementData中的值copy到新陣列中（當然，這時的elementData為空）
  3. 將初始化好的新陣列賦值給elementData

3.2 如何擴容

當我們瞭解了arrayList第一次新增元素的邏輯後，我們也基本明白了動態擴容的原理，其實就是建立一個新的陣列覆蓋之前的陣列，如圖：

但是有兩個問題：

  1. 何時擴容？
  2. 擴多大？

我們帶著疑問再去看下原始碼：

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

  // 當 elementData 沒有空閒的位置時，才去擴容
  // 即：第一次擴容是發生在 新增第11位元素時 11 - 初始長度10 > 0
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length; // 10
    // newCapacity = 10 + 10 / 2。
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 15
    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);
}

private static int hugeCapacity(int minCapacity) {
  if (minCapacity < 0) // overflow
    throw new OutOfMemoryError();
  return (minCapacity > MAX_ARRAY_SIZE) ?
    // 最大值：2的31次方
    Integer.MAX_VALUE :
  MAX_ARRAY_SIZE;
}

看到這裡，心中的疑惑就解開了：

  1. 當ArrayList內部的elementData[]沒有空閒位置時，才進行擴容。
  2. 每次將之前的size擴容1.5倍。

參考：

https://zhuanlan.zhihu.com/p/27873515

http://www.cnblogs.com/CarpenterLee/p/5419880.html

相關文章