Java集合源碼分析之ArrayList

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

前言：

既然是看源碼那咱們要怎麼看一個類的源碼呢？這裏我推薦的方法是：java

1）看繼承結構設計模式

看這個類的層次結構，處於一個什麼位置，能夠在本身內心有個大概的瞭解。api

2）看構造方法數組

在構造方法中，看作了哪些事情，跟蹤方法中裏面的方法。安全

3）看經常使用的方法數據結構

跟構造方法同樣，這個方法實現功能是如何實現的dom

注：既然是源碼，爲何要這樣設計類，有這樣的繼承關係。這就要說到設計模式的問題了。因此咱們要了解經常使用的設計模式，才能更深入的去理解這個類。函數

一：ArrayList簡介

1.一、ArrayList概述

  1. ArrayList是能夠動態增加和縮減的索引序列，它基於數組實現的List類。
  2. 該類封裝了一個動態再分配的Object【】數組，每個類對象都有一個capacity屬性，表示他們所封裝的Object【】數組長度，當向ArrayList中添加元素時，該屬性值會自動增長。若是想在ArrayList中添加大量元素，可以使用ensureCapacity方法一次性添加capacity，能夠減小增長重分配的次數，提升性能。
  3. ArrayList的用法和Vector向相似，可是Vector是一個較老的集合，具備不少缺點，不建議使用。另外，ArrayList和Vector的區別是：ArrayList是線程不安全的，當多條線程訪問同一個ArrayList集合時，程序須要手動保證該集合的同步性，而Vector則是線程安全的。

ArrayList的數據結構

分析一個類的時候，數據結構每每是它的靈魂所在，理解底層的數據結構其實就理解了該類的實現思路，具體的實現細節再具體分析。源碼分析

ArrayList的數據結構是：性能

　　　　

說明：底層的數據結構就是數組，數組元素類型爲Object類型，便可以存放全部類型數據。咱們對ArrayList類的實例的全部的操做底層都是基於數組的。

2、ArrayList源碼分析

2.一、繼承結構和層次關係

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

分析：

爲何要先繼承AbstractList，而讓AbstractList先實現List<E>？而不是讓ArrayList直接實現List<E>？

這裏是有一個思想，接口中全都是抽象的方法，而抽象類中能夠有抽象方法，還能夠有具體的實現方法，正是利用了這一點，讓AbstractList是實現接口中一些通用的方法，而具體的類，

如ArrayList就繼承這個AbstractList類，拿到一些通用的方法，而後本身在實現一些本身特有的方法，這樣一來，讓代碼更簡潔，就繼承結構最底層的類中通用的方法都抽取出來，

先一塊兒實現了，減小重複代碼。因此通常看到一個類上面還有一個抽象類。　　　

2.二、類中的屬性

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //版本號
    private static final long serialVersionUID = 8683452581122892189L;
    //缺省容量
    private static final int DEFAULT_CAPACITY = 10;
    //空對象數組
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //缺省空對象數組
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //元素數組
    transient Object[] elementData; // non-private to simplify nested class access
    //實際元素大小，默認爲0
    private int size;
    //最大數組容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

2.三、構造方法

ArrayList有三個構造方法：

1）無參構造方法　　

/**
 * 默認會給10的大小，因此一開始arrayList的容量就是10
 */
public ArrayList() {
    //是個空的Object[]，將elementData初始化，elementData也是個Object[]類型。空的object[]會默認賦值爲10，後面會提到何時賦值
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

備註：

transient Object[] elementData;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

　2）有參構造函數一

public ArrayList(Collection<? extends E> c) {
    //轉換爲數組
    elementData = c.toArray();
    //判斷數組中的數據個數
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        //每一個集合的toArray()的實現方法不同，因此須要判斷一下，若是不是Object[].class類型，那麼就要使用ArrayList方法去改造下。
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

總結：arrayList的構造方法就作一件事情，就是初始化一下儲存數據的容器，其實本質上就是一個數組，在其中就叫elementData。

2.四、核心方法

2.4.一、add()方法（有四個）

1）boolean add(E)；//默認直接在末尾添加元素

//添加一個特定的元素到list末尾
public boolean add(E e) {
    //肯定內部容量是否夠了，size是數組中數據的個數，由於要添加一個元素，因此size+1,先判斷size+1這個個數在數組中是否放的下，就在這個方法中去判斷是否數組.length是否夠用了。
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //在數據中正確的位置放上元素e,而且size++
    elementData[size++] = e;
    return true;
}

分析：ensureCapacityInternal(xxx);　肯定內部容量的方法　　　

private void ensureCapacityInternal(int minCapacity) {
    //先判斷初始化的elementData是否爲空數組，也就是沒有長度
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //由於若是是空的化，minCapacity =size+1;其實就是等於1，空的數組沒有長度就存不了了，因此就將minCapacity變成10，也就是默認大小，可是在這裏，尚未真正初始化這個elementData的大小
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //確認實際容量，上面只是將minCapacity =10，這個方法就是真正的判斷elementData是否夠用
    ensureExplicitCapacity(minCapacity);
}

ensureExplicitCapacity(xxx)；

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    //判斷minCapacity 若是大於了實際elementData的長度，那麼就說明elementData數組的長度不夠用，不夠用那麼就要增長elementData的length。     //一、minCapacity=size+1=1——>minCapacity=10,elementData.length =0     //二、minCapacity=size+1=11,elementData.length=10,結果>0就要去擴容，這裏舉個例子
    if (minCapacity - elementData.length > 0)
        //自動擴展大小
        grow(minCapacity);
}

grow(xxx); arrayList核心的方法，能擴展數組大小的真正祕密。

private void grow(int minCapacity) {
    // 將擴容前的elementData大小給oldCapacity
    int oldCapacity = elementData.length;
    //newCapacity =（1.5*oldCapacity）
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //newCapacity =0，minCapacity =10
    if (newCapacity - minCapacity < 0)
        //newCapacity =10
        newCapacity = minCapacity;
     //若是newCapacity超過了最大容量限制，就調用hugeCapacity，也就是將給的最大值給newCapacity
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 新的容量大小已經肯定好了，就copy數組，改變容量大小了
    elementData = Arrays.copyOf(elementData, newCapacity);
}

hugeCapacity();  

//用來賦最大值
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
  //兩層防禦
    return (minCapacity > MAX_ARRAY_SIZE) ?
        //Integer.MAX_VALUE:2147483647
        Integer.MAX_VALUE :
        //MAX_ARRAY_SIZE=2147483639
        MAX_ARRAY_SIZE;
}

2）void add(int，E)；在特定位置添加元素，也就是插入元素

public void add(int index, E element) {
    //檢測index，也就是插入的位置是否合理
    rangeCheckForAdd(index);
    //分析過了
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //這個方法就是用在插入元素以後，要將index以後的元素都日後移動一位
   System.arraycopy(elementData, index, elementData, index + 1, size - index);
    //在目標位置上存存放元素
    elementData[index] = element;
    //size+1
    size++;
}

分析：rangeCheckForAdd(index)　　

private void rangeCheckForAdd(int index) {
    //插入的位置確定不能大於size和小於0
    if (index > size || index < 0)
        //若是是，則數組越界異常
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

System.arraycopy(...)：就是將elementData在插入位置後的全部元素日後面移一位。

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);
src：源對象
srcPos：源對象對象的起始位置
dest：目標對象
destPost：目標對象的起始位置
length：從起始位置日後複製的長度。

總結：　　　　

正常狀況下會擴容1.5倍，特殊狀況下（新擴展數組大小已經達到了最大值）則只取最大值。

當咱們調用add方法時，實際上的函數調用以下：

說明：程序調用add，實際上還會進行一系列調用，可能會調用到grow，grow可能會調用hugeCapacity。

舉例說明一：　

ArrayList<Integer> lists = new ArrayList<Integer>();
lists.add(8);

說明：初始化lists大小爲0，調用的ArrayList()型構造函數，那麼在調用lists.add(8)方法時，會通過怎樣的步驟呢？下圖給出了該程序執行過程和最初與最後的elementData的大小。

說明：咱們能夠看到，在add方法以前開始elementData = {}；調用add方法時會繼續調用，直至grow，最後elementData的大小變爲10，以後再返回到add函數，把8放在elementData[0]中。

舉例說明二：　　

ArrayList<Integer> lists = new ArrayList<Integer>(6);
lists.add(8);

說明：調用的ArrayList(int)型構造函數，那麼elementData被初始化爲大小爲6的Object數組，在調用add(8)方法時，具體的步驟以下：

說明：咱們能夠知道，在調用add方法以前，elementData的大小已經爲6，以後再進行傳遞，不會進行擴容處理。

2.4.二、刪除方法

其實這幾個刪除方法都是相似的。咱們選擇幾個講，其中fastRemove(int)方法是private的，是提供給remove(Object)這個方法用的。

1）remove(int)：經過刪除指定位置上的元素

public E remove(int index) {
    //檢測index的合理性
    rangeCheck(index);
    //這個做用不少，好比檢測快速失敗的一種標誌
    modCount++;
    //經過索引直接找到該元素
    E oldValue = elementData(index);
    //計算要移動的位數
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //移動元素        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //將--size上的位置賦值爲null，讓gc（垃圾回收機制）更快的回收它
    elementData[--size] = null; // clear to let GC do its work
    //返回刪除的元素
    return oldValue;
}

2）remove(Object)：這個方法能夠看出來，arrayList是能夠存放null值得。

//經過元素來刪除該元素，就依次遍歷，就將該元素的索引傳給fastRemove（index），使用這個方法來刪除該元素
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;
}
//和remove方法實現差很少
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
}

3）clear()：將elementData中每一個元素都賦值爲null，等待垃圾回收將這個給回收掉，因此叫clear

/** * Removes all of the elements from this list. The list will * be empty after this call returns. */
public void clear() {
    modCount++;
    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

4）removeAll(collection c)：

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    //批量刪除
    return batchRemove(c, false);
}

5）batchRemove(xx,xx)：用於兩個方法，一個removeAll()：它只清楚指定集合中的元素，retainAll()用來測試兩個集合是否有交集。　

private boolean batchRemove(Collection<?> c, boolean complement) {
    //將原集合記爲A
    final Object[] elementData = this.elementData;
    //r用來控制循環，w是記錄有多少個交集
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            //參數中的集合c一次檢測集合A中的元素是否有
            if (c.contains(elementData[r]) == complement)
                //有就給集合A
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        //若是contains方法使用過程報異常
        if (r != size) {
            //將剩下的元素都賦值給集合A
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

總結：：remove函數用戶移除指定下標的元素，此時會把指定下標到數組末尾的元素向前移動一個單位，而且會把數組最後一個元素設置爲null，

2.4.三、set()方法

public E set(int index, E element) {
    //檢測索引是否合法
    rangeCheck(index);
    //舊值
    E oldValue = elementData(index);
    //賦新值
    elementData[index] = element;
    //返回舊值
    return oldValue;
}

說明：設定指定下標索引的元素值

2.4.四、indexOf()方法

//從首開始查找數組中是否存在指定元素
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;
}

說明：從頭開始查找與指定元素相等的元素，注意，是能夠查找null元素的，意味着ArrayList中能夠存放null元素的。與此函數對應的lastIndexOf，表示從尾部開始查找。

2.4.五、get()方法

public E get(int index) {
    //檢測索引合法性
    rangeCheck(index);

    return elementData(index);
}

說明：get函數會檢查索引值是否合法（只檢查是否大於size，而沒有檢查是否小於0），值得注意的是，在get函數中存在element函數，element函數用於返回具體的元素，具體函數以下：

E elementData(int index) {
    return (E) elementData[index];
}

說明：返回的值都通過了向下轉型（Object -> E），這些是對咱們應用程序屏蔽的小細節。

3、總結　

一、arrayList是能夠存放null。

二、arrayList本質就是一個elementData數組。

三、arrayList區別於數組的地方在於可以自動擴展大小，其中關鍵方法就是grow（）方法

四、arrayList中的removeAll（Collection c）和clear（）的區別就是removeAll能夠刪除批量指定元素，而clear是全是刪除集合中的元素。

五、arrayList因爲本質是數組，因此它在暑假查詢方面會很快，而在插入刪除這些方面，性能降低不少，要移動不少數據才能達到應有的效果。

六、arrayList實現了RandomAccess,因此在遍歷它的時候推薦使用for循環

補充：RandomAccess接口：這個是一個標記性接口，經過查看api文檔，它的做用就是用來快速隨機存取，有關效率的問題，在實現了該接口的話，那麼使用普通的for循環來遍歷，性能更高，例如arrayList。

原文連接：https://www.cnblogs.com/zhangyinhua/

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