ArrayList源碼分析

時間  2019-11-16
標籤 arraylist 源碼 分析 欄目 Java 简体版
原文   原文鏈接

本文以Java8爲例java

從ArrayList實現的接口提及

查看ArrayList源碼會發現ArrayList繼承了AbstractList類，實現了List, RandomAccess, Cloneable, java.io.Serializable接口。

AbstractList

AbstractList是抽象類，裏面有衆多List基本方法的基本實現。事實上JDK中有衆多相似AbstractXXX的類，他的思想是就是把衆多公共的實現提取出來，AbstractXXX面向的是工具類的開發者，咱們能夠基於AbstractList來實現本身的List。而ArrayList只是JDK已經幫咱們實現好的，面向工具類的使用者。數組

List

很少說，多態。父類的引用指向子類的實例。安全

RandomAccess

RandomAccess即隨機訪問。bash

先給出結論：集合中元素的訪問分爲隨機訪問和順序訪問。 隨機訪問相似於數組下標的訪問，順序訪問相似於鏈表的訪問，隨機訪問直接經過下標取值性能較好，順序訪問以迭代器遍歷性能比較好。 查看RandomAccess接口，僅僅是一個空接口而已。app

查看調用RandomAccess接口的類，發現除了實現RandomAccess，其餘都是用於instaceof判斷。

原來，RandomAccess用意僅僅是一個標記而已，即標記接口，用於判斷List是否爲RandomAccess的實現。以Collections的binarySearch方法爲例：dom

二分查找先判斷list是不是RandomAccess的子類或大小是否小於閾值5000，若是爲真則會執行indexedBinarySearch

會發現indexedBinarySearch是以數組下標的方式獲取值。若是爲假會執行iteratorBinarySearch

iteratorBinarySearch是以迭代器的方式獲取值。即JDK以性能方面的考慮，若是list支持隨機訪問或size比較小，則如下標索引的方式獲取內容，不然以迭代器的遍歷獲取內容。

因此RandomAccess僅僅是一個類的標記而已。函數

Cloneable

Cloneable是否可克隆，查看Cloneable接口 工具

查看調用Cloneable接口的類，都是實現Cloneable接口。與RandomAccess相似，Cloneable接口也是標記接口，用於判斷該類的對象是否可克隆。

這裏會有一個疑問：什麼是可克隆？源碼分析

先給出結論：clone方法是基類Object的方法，只有實現了Cloneable接口的類纔可使用clone方法，不然會拋CloneNotSupportedException異常。下面是某版本JDK的clone方法的源碼，會發現若是不是Cloneable的子類則會拋異常。性能

protected Object clone() throws CloneNotSupportedException {
    if (!(this instanceof Cloneable)) {
        throw new CloneNotSupportedException("Class " + getClass().getName() +
                                             " doesn't implement Cloneable");
    }

    return internalClone();
}

/*
 * Native helper method for cloning.
 */
private native Object internalClone();
複製代碼

然而查看JDK1.8的clone方法，僅僅是一個本地方法而已，他又是怎麼作到拋異常的呢？

protected native Object clone() throws CloneNotSupportedException;
複製代碼

原來在JDK1.8中，若是咱們查看JVM的C++源碼，會發現「對象是否實現了cloneable接口拋異常」的動做實如今了JVM層中。

因此ArrayList經過實現了cloneable接口，支持clone方法。

另外，有說法認爲Java的類經過實現Cloneable來標識出對象是否可使用clone是一種很糟糕的設計，未實現Cloneable確對外暴露clone方法的規則很奇怪。按照如今的視角來看，若是給類從新設計下「是否可克隆」這個規則，該怎麼實現好呢？這裏存疑。

java.io.Serializable

一樣也是標記接口，表示該類的對象是否能夠序列化。

成員屬性

// 若初始化時未指定容量大小，默認爲10
private static final int DEFAULT_CAPACITY = 10;

// 一個空數組而已
private static final Object[] EMPTY_ELEMENTDATA = {};

// 也是一個空數組，只不過與EMPTY_ELEMENTDATA作區分。
// DEFAULTCAPACITY_EMPTY_ELEMENTDATA表示初始化是無參構造
// 而EMPTY_ELEMENTDATA是有參構造，只不過參數是0
// 之因此用來區分是由於無參構造是默認容量爲10
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// 存儲對象的容器
transient Object[] elementData;

// 存儲對象的多少
private int size;

複製代碼

主要方法

構造方法

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() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
複製代碼

三個構造方法參數分別是容量、空、集合。經過觀察代碼會發現容量爲0時， this.elementData有兩種狀況

構造函數傳入initialCapacity時this.elementData = EMPTY_ELEMENTDATA;

無參構造函數時this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

關於這兩個屬性，源碼給的解釋是

/**
 * Shared empty array instance used for empty instances.
 * 用於空實例的共享空數組實例
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 * 共享空數組實例，用於默認大小的空實例。
 * 咱們將其與EMPTY_ELEMENTDATA區分開來，以瞭解添加第一個元素時應該膨脹多少
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
複製代碼

DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA其實就是實例化ArrayList方式的區分。

DEFAULTCAPACITY_EMPTY_ELEMENTDATA在後面add方法中會詳細解釋，其實這裏能夠理解爲DEFAULTCAPACITY_EMPTY_ELEMENTDATA表示實例化時是無參構造，未指定容量，在調用add方法時這種狀況會默認此刻容量爲10。

而EMPTY_ELEMENTDATA表示在咱們實例化對象時指定了容量就是0。

add方法

public boolean add(E e) {
    // 內部確保容量
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}


public void add(int index, E element) {
    rangeCheckForAdd(index);
    // 內部確保容量
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
            size - index);
    elementData[index] = element;
    size++;
}
複製代碼

add方法的核心ensureCapacityInternal，內部確保容量。

內部確保容量即add元素時，程序裏經過當前的size自動判斷當前是否須要擴容。與其相對應的是顯示確保容量。ensureCapacityInternal源碼分析以下

// minCapacity表示容器要確保支持的容量
// elementData的長度至少要大於等於minCapacity，是需求的最低大小
// 好比add時 minCapacity就是size+1
// ensureCapacity調用ensureCapacity顯示擴容時，minCapacity就是傳入的參數
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 該方法僅僅是多作了一步判斷，若是是以new ArrayList()無參構造函數實例化的對象，且是第一次add元素，則默認的最小容量爲10。
// 若是沒有默認容量，由於容器最初容量小，add元素時1.5倍的擴容方式會形成頻繁的擴容。
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

// 顯示確保容量，在ensureCapacityInternal中調用只是方法的公用
// 「顯示」的含義主要體如今ensureCapacity方法的調用，ensureCapacity是人爲的顯示擴大容量
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 實際擴容，默認按1.5被擴容，若是1.5倍仍是小於minCapacity，則以minCapacity爲準
private void grow(int minCapacity) {
    // overflow-conscious code
    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);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}
複製代碼

若是未指定容量，add方法以10爲初始值，每次擴容以1.5倍擴容。因此若是有大量數據add，也會觸發屢次擴容。而每次擴容其實是將數組內容複製到新的數組裏。

trimToSize

精簡化容器。ArrayList在實際使用中，elementData的長度大於等於size，而trimToSize會將elementData按照size從新複製一份給elementData，最小化ArrayList實例的存儲。若是實例內容不變，能夠調用該方法節約內存。

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
                ? EMPTY_ELEMENTDATA
                : Arrays.copyOf(elementData, size);
    }
}
複製代碼

ensureCapacity

至關於擴容，也是咱們前面提到的顯示確保容量。

給定一個minCapacity，保證ArrayList能夠容納至少minCapacity數量的對象。

public void ensureCapacity(int minCapacity) {
    // 以此來判斷咱們實例化時是否爲 new ArrayList()
    // 若是是，他的默認長度在add時就是10，不須要擴容
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ? 0
            : DEFAULT_CAPACITY;
    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}
複製代碼

clone

前面已經作過度析，經過實現Cloneable接口，使得clone方法可用。重寫clone方法，複製出一份數組，但其自己仍是淺拷貝，數組裏引用的對象沒有被複制。

modCount表示改動次數，新克隆的對象置爲0。

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable throw new InternalError(e); } } 複製代碼

remove

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

public boolean remove(Object o) {
    if (o == 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++;
    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
}
複製代碼

remove其實就是將index後面的元素向前移動一位。因此若ArrayList很大，不適合使用remove方法。

與Vector對比

Vector就是線程安全版的ArrayList，它的實現與ArrayList基本相似，這裏說下比較明顯的3點區別

Vector線程安全

Vector針對容器的操做都加上了synchronized關鍵字來保證線程安全，譬如：

public synchronized void ensureCapacity(int minCapacity) {
    if (minCapacity > 0) {
        modCount++;
        ensureCapacityHelper(minCapacity);
    }
}
複製代碼

構造方法略有不一樣

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
} 
複製代碼

相比ArrayList，Vector多了一個構造方法，多傳入一個參數capacityIncrement，能夠用來指定每次擴容的增量。

另外new Vector()默認容量也是10，只不過在實例化時數組的長度就已是10了。而ArrayList中是add第一個元素以後數組的長度纔會變成10。

public Vector() {
    this(10);// 默認容量爲10
}

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}
複製代碼

擴容規則略有不一樣

Vector的擴容方法

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 若是有capacityIncrement，按照capacityIncrement擴容，不然按照當前容量的一倍擴容
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
            capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}
複製代碼

Vector的擴容默認是按一倍擴容，若是指定capacityIncrement，則按照capacityIncrement擴容。

然而就我而言，對Vector應用幾乎沒有應用到。若是須要線程安全的List通常使用的是CopyOnWriteArrayList。

與LinkedList對比

LinkedList就是個雙向鏈表結構，每一個節點維護其前置節點和後驅節點。

LinkedList的源碼比較簡單就不作分析了。

ArrayList是線性結構支持RandomAccess，LinkedList是鏈式結構。

總結

  • 實現RadomAccess隨機訪問，使得ArrayList在一些方法中是以數組下標取值。

  • 實現CloneAble支持克隆，淺拷貝。

  • 默認容量爲10，以1.5倍遞增的方式擴容。

  • 數據量大時並不適合remove。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程