2. 程式人生 > >JDK集合原始碼分析（一）ArrayList

JDK集合原始碼分析（一）ArrayList

阿新 • • 發佈：2018-12-16

1.ArrayList簡介

1）對陣列的封裝。可以動態增長和縮減。是一種基於陣列實現的List類。是一種順序表。 2）ArrayList和Vector比較。Vector是一個較老的集合，具有很多缺點，不建議使用。ArrayList是執行緒不安全的，當多條執行緒訪問同一個ArrayList集合時，程式需要手動保證該集合的同步性，而Vector則是執行緒安全的。 3）ArrayList的類圖 （圖片來自百度相簿） 在這裡插入圖片描述

2.類繼承結構：

在這裡插入圖片描述

3.類中的屬性

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

   //預設的空物件陣列 
   //預設使用的初始化陣列 和上面區別在於當第一個元素被加入進來的時候它知道如何擴張在add(E e)中第一行體現
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; 

    //元素陣列
    transient Object[] elementData; // non-private to simplify nested class access

    //實際元素大小，預設為0
    private int size;

4.構造方法

ArrayList有三個構造方法： 在這裡插入圖片描述

4.1無參構造方法

/**
	 * ArrayList三個構造方法
	 * 作用就是初始化核心陣列 elementData
	 */
	 
	 //建構函式三者之一：無參構造()
	//預設容量10，實際Object陣列賦值一個預設的空物件陣列
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

4.2有參構造方法——指定大小

 //建構函式 三者之二：指定初始大小（int）
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {  
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {  	//如果自定義大小小於0，報非法資料異常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

4.3有參構造方法——指定大小

    //建構函式三者之三：構造(Collection) 不常用
	//用法：將Collection<Student> 轉換為 source.ArrayList<Person>
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();  //先轉換為陣列
        if ((size = elementData.length) != 0) {  //陣列元素不為0
            if (elementData.getClass() != Object[].class) //每個集合的toarray()的實現方法不一樣 所以判斷若返回不是Object[]型別，則用Arrays轉換成Object型別
                elementData = Arrays.copyOf(elementData, size, Object[].class);  //拷貝成Object型別的陣列
        } else {
            //陣列個數為0，則賦值空物件陣列
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

粘上copyOf的實現： 在這裡插入圖片描述

5.主要方法

5.1 add()方法(有4個)

在這裡插入圖片描述 在這裡插入圖片描述

1）boolean add(E)；//預設直接在末尾新增元素

 // add方法四之一：（E）
    public boolean add(E e) {
        ensureCapacityInternal(size + 1); //判斷新增一個後容量變成size+1的這個個數 陣列能否放得下 和陣列.length比較 // Increments modCount!!
        elementData[size++] = e;  //新增在陣列末尾
        return true;
    }

2）void add(int，E)；在特定位置插入元素

 // add方法四之二：在特定位置插入元素
    public void add(int index, E element) {
        rangeCheckForAdd(index);  //不在0~size之內的，就丟擲IndexOutOfBoundsException

        ensureCapacityInternal(size + 1);  //確保容得下插入的元素// Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index); //從index開始所有的元素都後移一格
        elementData[index] = element;//然後把要插入的元素放到index位置
        size++;
    }

 //確保minCapacity不會超出現在的陣列大小
    private void ensureCapacityInternal(int minCapacity) {  //minCapacity表示當前實際size+1，放第一個元素時size(0)+1=1
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  //假如元素陣列還是空陣列，空陣列沒法放元素，需要確定初始增加多大容量
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//DEFAULT_CAPACITY=10；minCapacity是10一下全為10,10以上為minCapacity
        }

        //上面只是提升擴容的閾值（10）
		//確認實際的容量，上面只是第一次放元素時將minCapacity=10，而後來放元素相當於只是對ensureExplicitCapacity的封裝
        ensureExplicitCapacity(minCapacity);
    }
    //確保minCapacity不會超出現在的陣列大小(超過就擴容)
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;  //修改次數自增
		 /*第一種情況：由於elementData初始化時是空的陣列，那麼第一次add的時候，minCapacity=size+1；也就minCapacity=1，在上一個方法(確定內部容量ensureCapacityInternal)就會判斷出是空的陣列，就會給
		　將minCapacity=10。
		　第二種情況：elementData不是空的陣列，那麼在add的時候，minCapacity=size+1；也就是minCapacity代表著elementData中增加之後的實際資料個數，拿著它判斷elementData的length是否夠用，如果length
		  不夠用，那麼肯定要擴大容量。
		 */
        if (minCapacity - elementData.length > 0) //minCapacity如果大於了實際elementData陣列的長度，那麼就說明elementData陣列的長度不夠用，
			//arrayList能自動擴充套件大小的關鍵方法就在這裡了
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        int oldCapacity = elementData.length; //擴充前的elementData大小
        int newCapacity = oldCapacity + (oldCapacity >> 1);//newCapacity就是1.5倍的oldCapacity
        if (newCapacity - minCapacity < 0)//如果擴充1.5倍還是不夠 那就用minCapacity 
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0) //如果newCapacity超過了最大的容量限制(Integer.MAX_VALUE - 8)(這個數字可能其他地方會用到，所以有這麼一出)，就呼叫hugeCapacity，也就是將能給的最大值（Integer.MAX_VALUE）給newCapacity
            newCapacity = hugeCapacity(minCapacity);
		 //新的容量大小已經確定好了，就copy陣列，改變容量大小。
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

3）boolean addAll(Collection<? extends E> c) 在末尾插入所有collection中的元素

//add方法四之三： 往末尾插一個Collection
    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); //從a陣列拷貝到elementData陣列
        size += numNew;
        return numNew != 0;
    }

4）boolean addAll(int index, Collection<? extends E> c) 往指定位置插一個Collection

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);  //從index開始的元素統統向後移動index+numNew

        System.arraycopy(a, 0, elementData, index, numNew);//再將a陣列放到index位置
        size += numNew;
        return numNew != 0;
    }

5.2 刪除方法

在這裡插入圖片描述 這幾個刪除方法都是類似的。我們選擇幾個看 在這裡插入圖片描述

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

 //刪除方法5 之1：刪除指定位置上的元素
    public E remove(int index) {
        rangeCheck(index);  //元素大於等於size 拋異常

        modCount++;   //修改次數 加1
        E oldValue = elementData(index);  //獲取老值，以便回收

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);  //index後面的所有元素都前移一格
        elementData[--size] = null; //所有元素前移後，最後一個元素沒用了，置空，儘快回收  // clear to let GC do its work

        return oldValue;
    }

//不用檢測負的，因為如果索引為負，會在訪問陣列的時候，丟擲ArrayIndexOutOfBoundsException
 private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

2）remove(Object)：根據Object元素查詢刪除此object

 //刪除方法5 之2：根據Object元素查詢刪除此object
    public boolean remove(Object o) {
        if (o == null) {   //要刪除 null  最主要是知道arrayList可以儲存null值！！！
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {//刪掉遇到的第一個null元素
                    fastRemove(index);
                    return true;   //刪除成功返回true
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {  //用equals判斷
                    fastRemove(index); //刪除遇到的第一個o元素
                    return true;  //刪除成功返回true
                }
        }
        return false;   //刪除失敗返回false
    }

    //私有方法，僅供remove(Object)使用，相比public的remove，"快"在了： 1.沒有邊界檢查(因為在remove(Object)中已經確保了邊界) 2.沒有返回刪除掉的元素
    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; //將最後一個置為null 儘快回收// clear to let GC do its work
    }

3）removeAll(collection c)：//批量刪除

 //刪除在Collection c中的所有元素
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c); //確保c非空 否則拋NullPointerException 空指標異常
        return batchRemove(c, false);  //批量刪除
    }
    // 刪除存在於Collection c 中的所有的所有元素
    //用於兩個方法，（complement為false時） removeAll()：清除指定集合中的元素；（complement為true時）retainAll()用來測試兩個集合是否有交集。　
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;  //r用來控制迴圈，w是記錄有多少個交集
        boolean modified = false;  //標記陣列結構是否修改過
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement) //依次檢查集合c中是否包含本元素陣列中的所有元素
                    elementData[w++] = elementData[r];  //從0開始，收集滿足條件的元素(不包含或者包含)，這塊複用了elementData。如果complement是false，就是將不包含在c中的元素挑揀出來
        } finally {
            //如果contails方法使用過程報出異常
            if (r != size) {  //沒有遍歷完，篩選中途報了異常 說明遍歷中途丟擲了異常
             //將剩下的元素都賦值給elementData
                System.arraycopy(elementData, r,//將還沒有經過遍歷篩選的元素 全部拷貝到篩選出來的元素末尾
                                 elementData, w,
                                 size - r); //一共拷貝r到size-1位置的元素
                w += size - r; //實際挑揀出來的元素數目 加上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;  //this.elementData實際容量變為w(即只要挑選出來的元素)
                modified = true;
            }
        }
        return modified;
    }

附帶看下 clear()實現，它與remove不同

//將陣列中所有元素賦值為null  以便GC快速回收掉
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

5.3 indexOf()方法

//查詢某個元素的下標，對應lastIndexOf()是從尾部開始找
    public int indexOf(Object o) {
        if (o == null) {  //要查詢的元素為 null
            for (int i = 0; i < size; i++)  //查詢第一個為null的元素位置
                if (elementData[i]==null)
                    return i;
        } else {    //要查詢的元素不為 null
            for (int i = 0; i < size; i++)   //找到第一個此元素的下標返回
                if (o.equals(elementData[i])) //用equals比較，所以得分null和非null
                    return i;
        }
        return -1;
    }

5.4 get()方法

public E get(int index) {
        rangeCheck(index); //檢驗索引合法 index >= size 拋越界異常
        return elementData(index);
    }

5.5 set()方法

//在index位置覆蓋element元素
    public E set(int index, E element) {
        rangeCheck(index); //檢測索引合法 index >= size 拋異常

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;  //返回舊值
    }

6. 總結

1）（是陣列）arrayList本質上就是一個elementData陣列。 2）（能擴充套件）arrayList區別於陣列的地方在於能夠自動擴充套件大小，其中關鍵的方法就是gorw()方法。 3）（可放null）arrayList可以存放null。 4）（可置空）arrayList中removeAll(collection c)和clear()的區別就是removeAll可以刪除批量指定的元素，而clear是將集合中的元素全部置為null，以便快速回收。 5）arrayList由於本質是陣列，所以它在資料的查詢方面會很快，而且arrayList標記了RandomAccess，所以在遍歷它的時候推薦使用for迴圈；而在插入刪除這些方面，效能下降很多，有移動很多資料才能達到應有的效果。

相關推薦

JDK集合原始碼分析（一）ArrayList

1.ArrayList簡介 1）對陣列的封裝。可以動態增長和縮減。是一種基於陣列實現的List類。是一種順序表。 2）ArrayList和Vector比較。Vector是一個較老的集合，具有很多缺點，不建議使用。ArrayList是執行緒不安全的，當多條執行緒訪

Java 集合原始碼分析（一）HashMap

目錄 Java 集合原始碼分析（一）HashMap 1. 概要 2. JDK 7 的 HashMap 3. JDK 1.8 的 HashMap 4. Hashtable 5.

Flume NG原始碼分析（一）基於靜態properties檔案的配置模組

日誌收集是網際網路公司的一個重要服務，Flume NG是Apache的頂級專案，是分散式日誌收集服務的一個開源實現，具有良好的擴充套件性，與其他很多開源元件可以無縫整合。搜了一圈發現介紹Flume NG的文章有不少，但是深入分析Flume NG原始碼的卻沒有。準備寫一個系列分析一下Flume NG的

GCC原始碼分析（一）——介紹與安裝

原文連結：http://blog.csdn.net/sonicling/article/details/6702031     上半年一直在做有關GCC和LD的專案，到現在還沒做完。最近幾天程式設計的那臺電腦壞了，所以趁此間隙寫一點相關的分析和

Glide原始碼分析（一）從用法來看之with方法

繼續啃原始碼，用過Glide的人，肯定都覺得它好好用，我們一般只需要幾行程式碼，就可以達到我們想要的效果，可以在這個背後是什麼呢？就需要我們來看了。 我一般看原始碼，我喜歡先從用法來看，然後一步一步的再細扣，所以就先從用法來看Glide的整體流程。 用過Glide的人，用下面這段

zigbee 之ZStack-2.5.1a原始碼分析（一）

先看main， 在檔案Zmain.c裡面 main osal_init_system(); osalInitTasks(); ... ... SampleApp_Init( taskID ); // 使用者定義的任務

Docker Client原始碼分析（一）

主要內容： Docker Client在Docker中的定位，以及Docker Client原始碼的初步分析。 本文選取Docker拆分為DockerCE（社群版）和DockerEE（企業版）之後的Docker-CE的第一個穩定版本v17.06.0-ce。 https://github.com/docker

Hibernate使用及原始碼分析（一）

Hibernate使用及原始碼分析（一） 本篇文章主要通過hibernate初級使用分析一下原始碼，只是給初學者一點小小的建議，不喜勿噴，謝謝！ hibernate環境搭建 簡單使用 原始碼走讀 一 hibernate環境搭建 這裡直接

SpringCloud原始碼分析（一）--客戶端搭建

一、前言 上一節的註冊中心搭建完成了，本節開始搭建客戶端，其實對於springcloud的Eureka註冊中心而言，他本身就是服務端也是客戶端，我們上節待見服務端註冊中心的時候，已經通過配置來設定其不向自己註冊，和不去檢索服務的功能，保持了其作為服務註冊中心的相對的功能單一性。 二、pom檔案

Vue原始碼分析（一）：入口檔案

Vue原始碼分析（一）：入口檔案   首先開啟命令列，從github下載原始碼，下載到自己的工作目錄。 git clone https://github.com/vuejs/vue.git   這裡我下載的是2.5.17版本的，vue 原始碼是由各種模組用 rollup 工具

okhttp原始碼分析（一）——基本流程（超詳細）

1.okhttp原始碼分析（一）——基本流程（超詳細） 2.okhttp原始碼分析（二）——RetryAndFollowUpInterceptor過濾器 3.okhttp原始碼分析（三）——CacheInterceptor過濾器 4.okhttp原始碼分析（四）——Conn

spring事務管理原始碼分析（一）配置和事務增強代理的生成流程

在本篇文章中，將會介紹如何在spring中進行事務管理，之後對其內部原理進行分析。主要涉及 @EnableTransactionManagement註解為我們做了什麼？ 為什麼標註了@Transactional註解的方法就可以具有事務的特性，保持了資料的ACID特性？spring到底是如何具有這樣

Android系統播放器MediaPlayer原始碼分析（一）

前言 對於MediaPlayer播放器的原始碼分析內容相對來說比較多，會從Java->JNI->C/C++慢慢分析，後面會慢慢更新。另外，部落格只作為自己學習記錄的一種方式，對於其他的不過多的評論。 MediaPlayerDemo public class MainA

Android7.1 [Camera] Camera Hal 原始碼分析（一）

原始碼平臺：rk3399   命令列ls看下原始碼的結構 hardware/rockchip/camera/CameraHal： lib目錄 原始碼的檔案看起來有點多，我們看看Android.mk檔案， 這些檔案最終編譯成camera.rk30bo

Cat原始碼分析（一）：Client端

前言 cat的Client端所做的工作就是收集埋點資訊，將埋點資訊處理成messageTree，放到傳送佇列中，在啟動另一個執行緒，非同步消費佇列，進行訊息的傳送。 本文涉及到三個內容： 客戶端初始化：做了哪些準備工作 message的建立過程 客戶端的傳

laravel框架原始碼分析（一）自動載入

一、前言 　　使用php已有好幾年，laravel的使用也是有好長時間，但是一直對於框架原始碼的理解不深，原因很多，歸根到底還是php基礎不紮實，所以原始碼看起來也比較吃力。最近有時間，所以開啟第5、6遍的框架原始碼探索之旅，前面幾次都是看了一些就放棄，希望這次能夠看完。每一次看原始碼都會有新的收穫，因為框

github上hamsternz/FPGA_DisplayPort 的VHDL原始碼分析（一）

原始碼來源於https://github.com/hamsternz/FPGA_DisplayPort。由於我也是第一次接觸這個介面，所以文中肯定有我理解錯誤的地方，懇請指正。要看懂程式碼首先還是要對協議有一定了解。所以我做的原始碼分析中會和協議結合起來。 激勵檔案test_source_800

vue-element-admin原始碼分析（一）

這兩天看花褲衩大大的手摸手系列，使用vue+element+vuex+axios實現了一個後臺模板（專案地址），在閱讀原始碼的過程中收益匪淺，以下做一些筆記。（由於是學習大大專案的思想，所以略去了很多大大的程式碼）。 這裡只是做一個登陸頁面，然後能提交資料給後臺

lua原始碼分析（一）揭開 table 的神祕面紗

       友情提醒：閱讀本文前請先確保自己對雜湊表有足夠深入的理解，雜湊表的詳解可以參見以下這篇文章：Redis底層詳解（一） 雜湊表和字典。        lua 底層 table (也叫陣列, 物件

集合原始碼分析（六）HashMap集合

1、HashMap概述： 底層是雜湊演算法，針對鍵。HashMap允許null鍵和null值，執行緒不安全，效率高。鍵不可以重複儲存，值可以。 雜湊結構：不能保證資料的迭代順序，也不能保證順序的恆久不變。 Map集合（無序、無索引、不可以重複）是雙列集合，一個鍵對應一個