2. 程式人生 > >Java——ArrayList原始碼解析

Java——ArrayList原始碼解析

阿新 • • 發佈：2018-11-07

以下針對JDK 1.8版本中的ArrayList進行分析。

概述

    ArrayList基於List介面實現的大小可變的陣列。其實現了所有可選的List操作，並且元素允許為任意型別，包括null元素。除了實現List介面，此類還提供了操作內部用於儲存列表陣列大小的方法（這個類除了沒有實現同步外，功能基本與Vector一致）。

    每個ArrayList例項都有一個容量。容量是用於儲存列表中元素的陣列的大小。它始終至少與列表大小一樣大。隨著元素新增到ArrayList，其容量會自動增加。除了新增元素具有恆定的攤銷時間成本這一事實之外，增長策略並沒有詳細指出。

    我們在新增大容量資料的時候可以使用ensureCapacity方法來主動擴容，這可以減少自動擴容的次數。

    值得注意的是，這些實現都不是同步的。因此，當多個執行緒併發訪問一個ArrayList例項並且至少有一個執行緒對這個例項進行結構性調整的時候，必須在外部額外實現同步（對於結構性調整，主要指增加或刪除一個或多個元素，更精確的說，就是對這個列表的大小進行了調整，對於更改元素的數值並非是結構性調整）。這通常通過在自然封裝列表的某個物件上進行同步來完成。如果不存在此類物件，則應使用Collections.synchronizedList

方法“包裝”該列表。這最好在建立時完成，以防止意外地不同步訪問列表：List list = Collections.synchronizedList(new ArrayList(...));

    注意，迭代器的快速失敗行為無法得到保證，因為一般來說，不可能對是否出現不同步併發修改做出任何硬性保證。快速失敗迭代器會盡最大努力丟擲ConcurrentModificationException。因此，為提高這類迭代器的正確性而編寫一個依賴於此異常的程式是錯誤的做法：迭代器的快速失敗行為應該僅用於檢測 bug。

原始碼分析

主要欄位

/**
 * 預設初始容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 用於ArrayList空例項的共享空陣列例項
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 用於預設大小空例項的共享空陣列例項。我們將this（DEFAULTCAPACITY_EMPTY_ELEMENTDATA）
 * 和EMPTY_ELEMENTDATA區別開來，以便在新增第一個元素時知道陣列大小要擴容為多少多少。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 儲存 ArrayList 元素的陣列緩衝區。ArrayList 的容量是此陣列緩衝區的長度。
 * 當第一個元素新增進空陣列時候 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 將會被擴容至 DEFAULT_CAPACITY
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * ArrayList的陣列大小（ArrayList包含的元素個數
 */
private int size;

    注意此處的elementData欄位是用的transient修飾的以及對於空例項有DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA兩個共享空陣列例項，下面會對提到的這些注意點進行分析。

建構函式

/**
 * 根據指定的容量初始化空的列表，注意當容量為 0 時，使用的是 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);
    }
}

/**
 * 初始化容量為 10 的空列表
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 */
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;
    }
}

    注意到對於無參構造器使用的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，而對於帶參構造器，當 initialCapacity 為0時，使用的是EMPTY_ELEMENTDATA；另外，在無參構造器中的註釋——“初始化容量為10的空列表”，我們不禁有以下疑惑：

  • EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA都是空的物件陣列，為什麼在構造器中要對其進行區分
  • 無參構造器中，只是把空的物件陣列賦值給了elementData，為什麼註釋稱聲明瞭長度為10的空陣列

對於以上問題，將在儲存和擴容部分進行講解。

儲存和擴容

/**
 * 增加 ArrayList 例項的容量，確保 ArrayList 例項能儲存 minCapacity 個元素
 */
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        : DEFAULT_CAPACITY;

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

    當ArrayList例項是個空列表並且 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA時，minExpand 設定為DEFAULT_CAPACITY(10)，此時如果 minCapacity 小於 minExpand，那麼不馬上進行擴容操作，在進行add操作時候，會初始化一個容量為 10 的空列表，這樣不僅符合無參構造器中的註釋，並且保證了 ArrayList 例項能夠儲存 minCapacity 個元素。

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

    在add操作內部，會呼叫這個私有方法來確保有足夠的容量來放置元素。注意，這個函式一開始就對 elementData 進行判斷是否為 DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是的話，證明是無參構造器初始化的例項，在下一步會初始化一個容量為 10 的空列表，符合無參構造器中的註釋，其實就是一個延遲初始化的技巧。

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

    // 擴容操作
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
 * 允許分配的最大陣列大小
 *一些 VM 會在陣列頭部儲存頭資料，試圖嘗試建立一個比 Integer.MAX_VALUE - 8 大的陣列可能會產生 OOM 異常。
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * 增加 ArrayList 例項的容量，確保 ArrayList 例項能儲存 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);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

/**
 * 將指定的元素追加到此列表的末尾
 */
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

/**
 * 在列表中將指定元素插入到指定位置，將其後元素都向右移動一個位置
 */
public void add(int index, E element) {
    //檢查 index 是否越界
    rangeCheckForAdd(index);

    //確保有足夠的容量能夠新增元素
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

/**
 * 將指定集合中的全部元素新增到列表尾端
 */
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

/**
 * 將指定集合中的全部元素插入到列表指定的位置後面
 */
public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

    因此對於無參構造器的註釋的疑問，到達這裡就可以解答了，它確確實實初始化了一個大小為 10 的空列表，只是不是一開始就初始化，而是使用了延遲初始化的方式，在add的時候才進行初始化。     對於另一個問題，無參構造器使用DEFAULTCAPACITY_EMPTY_ELEMENTDAT，對於new ArrayList(0);使用的是EMPTY_ELEMENTDATA，前者是不知道需要的容量大小，後者預估元素較少。因此ArrayList對此做了區別，通過引用判斷來區別使用者行為，使用不同的擴容演算法（擴容速度：無參：10->15->22...，有參且引數為0 ：0->1->2->3->4->6->9...)。另外，在 JDK 1.7 中，沒有通過兩個空陣列來對使用者行為進行區分，因此容量為 0 的話，會建立很多空陣列new Object[0]，因此上述方式也對這種情況進行了優化。

//JDK 1.7
public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}


public ArrayList() {
    this(10);
}

刪除

/**
 * 從列表中刪除指定位置的元素，並將其後位置的元素向左移動
 */
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);
    //置null，讓 GC 可以工作
    elementData[--size] = null;
    return oldValue;
}

/**
 * 刪除列表中首次出現的指定的元素，若列表不存在相應元素，則不做改變
 */
public boolean remove(Object o) {
    //若指定元素為 null，因其為空，沒有 equals 方法，因此這兩個地方做一個區分
    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 remove method that skips bounds checking and does not
 * return the value removed.
 */
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
}

/**
 * 刪除列表中所有的元素
 */
public void clear() {
    modCount++;

    // 置 null 以便讓 GC 回收
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

/**
 * 從列表中刪除 fromIndex <= pos < toIndex 的元素
 */
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    System.arraycopy(elementData, toIndex, elementData, fromIndex,
                     numMoved);

    // clear to let GC do its work
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }
    size = newSize;
}

ArrayList的序列化

在 主要欄位 部分我們可以看到，elementData 是通過transient修飾的（transient具體用法可參看Java物件序列化一文），通過transient宣告，因此其無法通過序列化技術儲存下來，但仔細閱讀原始碼發現其內部實現了序列化和反序列化函式：

/**
 * 儲存 ArrayList 中例項的狀態到序列中
 */
private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

/**
 * 從序列中恢復 ArrayList 中例項的狀態
 */
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

通過一個例子驗證其序列化和反序列化過程：

package test;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        List<String>list = new ArrayList<>();
        list.add("hello");
        list.add("world");

        //write Obj to File
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("file"));
        oos.writeObject(list);
        oos.close();

        //read Obj from File
        File file = new File("file");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        List<String>newList = (List<String>) ois.readObject();
        ois.close();
        System.out.println(newList);
    }
}
/*
[hello, world]
 */

可以得出結論：ArrayList支援進行序列化操作，此時不禁會思考既然要將 ArrayList 的欄位序列化（即將 elementData 序列化），那為什麼又要用 transient 修飾 elementData 呢？實際上，ArrayList 通過動態陣列的技術，當陣列放滿後，自動擴容，但是擴容後的容量往往都是大於或者等於 ArrayList 所存元素的個數。如果直接序列化 elementData 陣列，那麼就會序列化一大部分沒有元素的陣列，導致浪費空間，為了保證在序列化的時候不會將這麼大部分沒有元素的陣列進行序列化，因此設定為 transient。

// Write out all elements in the proper order.
for (int i=0; i<size; i++) 
{
    s.writeObject(elementData[i]);
}

從原始碼中，可以觀察到迴圈時是使用i < size而不是i<elementData.length，說明序列化時，只需實際儲存的那些元素，而不是整個陣列。

問題

  • List<Integer>list = new ArrayList<>(10); out.println(list.get(1));是否會丟擲異常
  • ArrayList 支援序列化，為什麼 elementData 要設定為transient
  • 對於空例項陣列，為什麼要區分DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA

相關推薦

Java——ArrayList原始碼解析

以下針對JDK 1.8版本中的ArrayList進行分析。 概述     ArrayList基於List介面實現的大小可變的陣列。其實現了所有可選的List操作，並且元素允許為任意型別，包括null元素。除了實現List介面，此類還提供了操作內部用於儲存列表陣列大小

Java集合框架——jdk 1.8 ArrayList 原始碼解析 System.arraycopy 怎麼使用的？

前言：作為菜鳥，需要經常回頭鞏固一下基礎知識，今天看看 jdk 1.8 的原始碼，這裡記錄 ArrayList 的實現。 一、簡介 　　ArrayList 是有序的集合； 　　底層採用陣列實現對資料的增刪查改； 　　不是執行緒安全的； 　　有自動擴容的功能。 二、類圖  

Java原始碼解析系列（二）ArrayList原始碼解析

備註：以下都是基於JDK8 原始碼分析 ArrayList簡介        ArrayList 是一個數組佇列，相當於 動態陣列。與Java中的陣列相比，它的容量能動態增長。它繼承於AbstractList，實現了List, RandomAccess, Clonea

Java集合（一）-ArrayList原始碼解析

ArrayList是什麼？ ArrayList是Java集合中的一份子，它的內部結構實為陣列並封裝了一些方法和特性方便使用者，為什麼不用陣列呢？因為ArrayList更加方便：如果你再不確定元素個數的情況下建立一個數組，那麼在陣列容量不夠的情況下需要手動擴容（也就是重新初始

Java集合（一）：ArrayList原始碼解析

前言今天來介紹下ArrayList，在集合框架整體框架一章中，我們介紹了List介面，ArrayList繼承了AbstractList，實現了List。ArrayList在工作中經常用到，所以要弄懂這個類是極其重要的。構造圖如下:藍色線條：繼承綠色線條：介面實現正文Array

Java——HashMap原始碼解析

以下針對JDK 1.8版本中的HashMap進行分析。 概述     雜湊表基於Map介面的實現。此實現提供了所有可選的對映操作，並且允許鍵為null，值也為null。HashMap 除了不支援同步操作以及支援null的鍵值外，其功能大致等同於 Hashtable。

java集合原始碼解析（三）--List

今天給大家帶來有序集合的介面List，我想也應該是大家在工作中用的比較多的 先來看看介面的定義： public interface List<E> extends Collection<E>可以看出介面List直接繼承於介面Collection，並且一樣使用了

java集合原始碼解析（二）--AbstractCollection

今天帶來的是java單列頂層介面的第一個輕量級實現：AbstractCollection 我們直接進入正題，先來看看它的宣告： package java.util; //可以從名字上同樣看到 AbstractCollection 是一個抽象類，所以並不能例項化， //這個類只是作

Java ThreadLocal原始碼解析: ThreadLocalMap

ThreadLocalMap在比其中Thread和ThreadLocal部分要複雜很多，是ThreadLocal底層儲存和核心資料結構。從整體上將，ThreadLocalMap底層是Entry陣列，key值為ThreadLocal的hash code, 採用線性探測法解決雜湊衝突。 以下

Java ThreadLocal原始碼解析: Thread和ThreadLocal

之前對TreadLocal有所理解，對原理也有所瞭解，但一直不深入，重新整理，希望藉以加深理解和印象。 在Jdk1.8中，ThreadLocal相關程式碼主要分為三部分： Thread，其中Thread中儲存對ThreadLocal.ThreadLocalMap的引用，作為T

【JAVA,ArrayList原始碼】閱讀ArrayList原始碼個人理解

閱讀ArrayList原始碼個人理解 近期閱讀了java.util.ArrayList.java的原始碼 ArrayList介紹 從貼出程式碼不難看出，ArrayList是繼承了AbstractList，並且實現了List，RandomAccess，Cloneable，

Java 集合原始碼解析（1）：Iterator

Java 提供的 集合類都在 Java.utils 包下，其中包含了很多 List, Set, Map, Queue… 它們的關係如下面這張類圖所示： 可以看到，Java 集合主要分為兩類：Collection 和 Map. 而 Collection 又繼承了 Iter

ArrayList原始碼解析

概要 ArrayList 是一個動態陣列，它是執行緒不安全的，允許元素為null。 其底層資料結構依然是陣列，它實現了List, RandomAccess, Cloneable, java.io.Serializable介面，其中RandomAccess代表了其

Java JDK原始碼解析之：native方法

初次看見native關鍵字是自己在看Scanner類原始碼中傳遞System.in引數實現列印，之後轉到System觀看原始碼時看見native關鍵字，關於native關鍵字筆者表示，是Java與C語言的通訊介面，因為Java語言沒有操作底層的條件，所以Java

Java集合原始碼解析：TreeMap

本文概要 二叉查詢樹的用處 二叉查詢樹，以及二叉樹帶來的問題 平衡二叉樹的好處 紅黑樹的定義以及構造 紅黑樹在TreeMap的運用 二叉樹的好處 可能許多人會有疑問，為什麼要使用二叉樹，有那麼多的資料結構，比如陣列、連結串列等 簡單看下陣列和連結串列的優缺點

Java集合原始碼解析：HashMap

本文概要 HashMap概述 HashMap資料結構 HashMap的原始碼解析 HashMap概述 在官方文件中是這樣描述的: Hash table based implementation of the Map interface. This imple

資料結構-ArrayList原始碼解析

一、ArrayList簡介 1.1、ArrayList概述 　　1）ArrayList是個動態陣列，它是基於陣列實現的List類。 　　2）該類封裝了一個動態再分配的Object[]陣列，每一個類物件都有一個capacity屬性，表示它們所封裝的Object[]陣列的長度，當向ArrayList中新增元

java 列舉原始碼解析

應用場景 列舉通常用來列舉一個型別的有限例項集合，我們可以使用常量集來實現，jdk1.5添加了列舉（enum）支援，解決了常量集的一些缺陷 常量集中的變數不會必然在指定的範圍內 常量能夠提供的功能很少，難於使用 常量意義不明確，沒有名字 修改或增加列舉值後

JAVA集合原始碼解析 Hashtable探索（基於JDK1.8）

JDK1.8Hashtable探索 本文的討論分析是基於JDK1.8進行的 依舊是採用前幾篇文章的大綱來進行介紹 1.簡介 Hashtable 採用陣列+單鏈表來實現的，Hashtable 實現了一個雜湊表，它將鍵對映到值。任何非 nu

Java String原始碼解析

String類概要 所有的字串字面量都屬於String類，String物件建立後不可改變，因此可以快取共享，StringBuilder，StringBuffer是可變的實現 String類提供了操作字元序列中單個字元的方法，比如有比較字串，搜尋字串等 Jav