技術文章 » 搞懂ArrayList其實很簡單。來，我教你！

搞懂ArrayList其實很簡單。來，我教你！

2020-10-22 11:00:25

前言

昨天寫了一篇有關HashMap的文章：這些年，被面試官問到的HashMap，反響不錯。於是今天就是想寫篇文章來介紹ArrayList，那現在我們就來好好聊聊ArrayList。

Ps： 這裡我也整理了一些最近群友去面試整理的面試資料，提供大家參考！還是感謝群友的開源精神！

在這裡插入圖片描述

有需要的小夥伴可以點選進入暗號：csdn，免費獲取。還有更多Java專題檔案筆記。

正文

ArrayList相比HashMap來說就比較簡單了，先來看看實現了哪些介面：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
        
//預設容量大小            
private static final int DEFAULT_CAPACITY = 10;
//指定ArrayList容量為0時返回該陣列
private static final Object[] EMPTY_ELEMENTDATA = {};
//當沒有指定ArrayList容量時返回該陣列
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//儲存新增到ArrayList中的元素（ArrayList的底層其實就是一個陣列）
transient Object[] elementData; 
//ArrayList中元素數量
private int size;
.....
}

從上面的原始碼我們可以提取出下面幾個關鍵資訊：

  • ArrayList底層使用一個Object型別的陣列來儲存資料
  • ArrayList預設大小為10

可以看到ArrayList底層是使用一個陣列elementData來儲存資料的，因此也被稱為動態陣列。值得注意的是用了elementData用了transient修飾。

transient表示elementData無法被序列化，為什麼要這麼設定呢？

因為elementData裡面不是所有的元素都有資料，因為容量的問題，elementData裡面有一些元素是空的，這種是沒有必要序列化的。
ArrayList的序列化和反序列化依賴writeObject和readObject方法來實現。可以避免序列化空的元素。

接下來我們從常用建構函式入手：

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);
    }
}

上面兩個建構函式比較簡單，就是給對陣列做初始化，這裡不再細說。

ArrayList還有一個建構函式：

 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.
            //如果傳入的c長度為0，則替換成空陣列
            elementData = EMPTY_ELEMENTDATA;
        }
    }

首先呼叫toArray()返回一個陣列，因為不一定會返回Object型別，所以需要判斷一下型別，如果型別不同則呼叫Arrays.copyOf方法，我們來看看原始碼：

/*
 * 複製陣列，並轉型為指定型別
 * original——>原陣列  newLength——>要複製的長度  newType——>新型別
 */
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    //判斷是否是Object型別
    T[] copy = ((Object)newType == (Object)Object[].class)//（這裡不加(Object)強轉編譯器無法通過）
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        //getComponentType()——>本地方法，返回陣列內的元素型別，不是陣列時，返回null
        //Array.newInstance——>建立一個型別與newType一樣，長度為newLength的陣列
    System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));//截斷陣列
    return copy;
}

從註釋也可以看出該方法可以複製陣列，並轉型為指定型別，之前的啃碎JDK原始碼(一)：String已經對System.arraycopy做了介紹，感興趣的小夥伴可以去看看，這裡不再重述。

最新整理面試題

在這裡插入圖片描述

有需要的小夥伴可以點選進入暗號：csdn，免費獲取。還有更多Java專題檔案筆記。

新增元素

接下來是一個比較核心的方法add

/*新增元素到集合中*/
public boolean add(E e) {
    //判斷ArrayList是否需要擴容
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}
/*判斷是否需要擴容——> minCapacity是集合需要的最小容量*/
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/*返回新增元素後的容量大小*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //首次新增元素時，返回 minCapacity > 10 ? minCapacity : 10 （首次可能使用addAll方法新增大量元素）
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}
/*判斷是否需要擴容*/
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//modCount是繼承自AbstractList的變數，用來表示集合被修改的次數
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
/*擴容*/
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);//擴容為原來的1.5倍
    if (newCapacity - minCapacity < 0)//如果擴容後還是小於最小容量，則設定minCapacity為容量大小
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
        newCapacity = hugeCapacity(minCapacity);
    //呼叫Arrays.copyOf生成新陣列
    elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

到目前為止，我們就可以知道add(E e)的基本實現了：
新增元素時，首先去檢查一下陣列的容量是否足夠，如果不夠則擴容到原來的1.5倍
擴容後，如果容量還是小於minCapacity，就將容量擴充為minCapacity，最後呼叫Arrays.copyOf(elementData, newCapacity)方法生成新的陣列。

獲取、設定元素

下面看看get和set方法：

/*
 * 獲取index索引物件
 */
public E get(int index) {
    rangeCheck(index);//引數校驗
    return elementData(index);
}
E elementData(int index) {
    return (E) elementData[index];
}

/*
 * 設定index索引物件
 */
public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

兩個方法都比較簡單，這裡不再展開細說。

刪除元素

接下來看一下ArrayList如何刪除元素：

/*
 * 刪除index索引物件
 */
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; //設為null讓JVM回收

    return oldValue;//返回舊資料
}

做個簡單總結

  • 計算出需要左移的個數後，使用System.arraycopy方法截斷生成新陣列
  • 刪除元素後將最後一位設為null便於JVM回收

還有另外一個remove(Object o)方法：

/*
 * 刪除給定Object物件
 */
public boolean remove(Object o) {
    if (o == null) {//刪除null物件-->ArrayList可以存放null
        for (int index = 0; index < size; index++)
            if (elementData[index] == 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++;//修改次數+1
    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
}

這部分原始碼比較簡單，就是遍歷比較然後刪除。值得注意的是ArrayList可以存null值，因為需要對null引數做額外處理。

注意：呼叫remove刪除元素時不會減少容量，若希望減少容量則呼叫trimToSize(),比較簡單，下面直接貼上原始碼：

/*
 * 修改陣列尺寸
 */
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

最後再來介紹幾個平時用的比較多的方法：

我們平開發也會經常使用contains方法來判斷是否包含某個元素，下面看下是如何實現的：

/*
 * 判斷集合中是否包含某元素
 */
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

可以看到直接使用indexOf來判斷，和之前String原始碼比較類似，直接來看看程式碼：

/*
 * 返回指定元素第一次出現的位置（返回-1表示沒有此元素）
 * lastIndexOf——>同理（其實就是從後向前遍歷）
 */
public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

其實就是遍歷依次比較，相等則返回下標。

學習電子書整理

在這裡插入圖片描述

有需要的小夥伴可以點選進入暗號：csdn，免費獲取。還有更多Java專題檔案筆記。

總結

看完是不是覺得相比HashMap來說ArrayList的原始碼還是比較能看懂的，當然我們這裡只列出了一些比較常用的方法，像ArrayList其實還有一些Itr等內部類，其實就是我們平時用的迭代器，如果對這些感興趣的小夥伴可以自己去研究一下。

在這裡插入圖片描述