2. 程式人生 > >ArrayList原始碼學習筆記------常用API

ArrayList原始碼學習筆記------常用API

阿新 • • 發佈：2019-02-04

本文的原始碼來自於jdk1.8版本，然而並不會涉及jdk8新特性。

ArrayList簡介

ArrayList是基於陣列實現的，是一個動態陣列，其容量能自動增長，類似於C語言中的動態申請記憶體，動態增長記憶體。

ArrayList不是執行緒安全的，只能用在單執行緒環境下，多執行緒環境下可以考慮用Collections.synchronizedList(List l)函式返回一個執行緒安全的ArrayList類，也可以使用concurrent併發包下的CopyOnWriteArrayList類。

ArrayList實現了Serializable介面，因此它支援序列化，能夠通過序列化傳輸，實現了RandomAccess介面，支援快速隨機訪問，實際上就是通過下標序號進行快速訪問，實現了Cloneable介面，能被克隆。

ArrayList原始碼解析

在進行原始碼解析之前需要有以下的準備

1、transient關鍵字的作用
答：我們都知道一個物件只要實現了Serilizable介面，這個物件就可以被序列化，java的這種序列化模式為開發者提供了很多便利，我們可以不必關係具體序列化的過程，只要這個類實現了Serilizable介面，這個類的所有屬性和方法都會自動序列化。
然而在實際開發過程中，我們常常會遇到這樣的問題，這個類的有些屬性需要序列化，而其他屬性不需要被序列化，打個比方，如果一個使用者有一些敏感資訊（如密碼，銀行卡號等），為了安全起見，不希望在網路操作（主要涉及到序列化操作，本地序列化快取也適用）中被傳輸，這些資訊對應的變數就可以加上transient關鍵字。換句話說，這個欄位的生命週期僅存於呼叫者的記憶體中而不會寫到磁盤裡持久化。
總之，java 的transient關鍵字為我們提供了便利，你只需要實現Serilizable介面，將不需要序列化的屬性前新增關鍵字transient，序列化物件的時候，這個屬性就不會序列化到指定的目的地中。
2、原始碼中多次使用的Arrays類中的copyOf方法

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0
 
, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

該方法的作用是建立一個數組，並將original陣列中newLength個元素複製到新建立的陣列中。

ArrayList的成員變數

ArrayList的成員變數如下：

    /*定義集合底層陣列的預設容量為10*/
    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;

DEFAULTCAPACITY_EMPTY_ELEMENTDATA這個屬性貌似是jdk8才加入的，它和EMPTY_ELEMENTDATA的區別不大，只是兩者的使用情況不同。

ArrayList的建構函式

看程式碼可以發現ArrayList共有三個建構函式，其程式碼很易懂。

1、空參建構函式

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

2、建立集合時使用者指定ArrayList的初始容量

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

3、建立集合時使用者傳入一個指定的集合

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                //將傳入的集合複製一份，並將其賦給elementData
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //若傳入的集合為空，則使用空陣列替代
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

常用API原始碼

1、add(E e)方法
ArrayList的add方法幾乎包含了ArrayList最主要的流程，其中包含了是否需要對陣列進行動態擴容的判斷，也包含了陣列動態擴容的具體方式。

public boolean add(E e) {
       ensureCapacityInternal(size + 1); 
       elementData[size++] = e;
       return true;
}

ensureCapacityInternal(size + 1)方法的作用是在新增元素之前確定ArrayList的容量大小，其中size變數的值為當前ArrayList中的陣列的長度。這樣做的目的是用於判定本次新增元素的操作是否需要對底層的陣列進行擴容。

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    //如果當前是首次向陣列中新增元素，則返回當前所需要的最小容量和預設陣列容量的最大值
    //該值最終為本次新增元素操作所需要的最小陣列長度
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    //判定是否需要對陣列elementData進行擴容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

陣列的動態擴容

    //動態擴容的方法
    private void grow(int minCapacity) {
        //舊的陣列的長度
        int oldCapacity = elementData.length;
        //新的陣列的長度為舊陣列長度的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果舊陣列的長度依舊無法滿足要求，則使用minCapacity為新陣列的長度
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果新陣列的長度超過了規定的陣列的最大長度（MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8）
        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) {
        //minCapacity < 0，即minCapacity的值已經超出int型別的最大值
        if (minCapacity < 0) 
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

根據以上的學習可以總結出
1、ArrayList底層陣列的最大長度為int型別的長度。
2、ArrayList底層陣列在進行動態擴容時，陣列的長度每次增加1.5倍。
3、陣列新增單個元素的主要流程為，先計算出本次新增元素所需要的最小陣列長度x，再比較x與elementData.length的大小，當x的大小大於elementData.length的長度時，再對ArrayList底層陣列elementData進行擴容。

2、將元素插入到指定的所引處，public void add(int index,E element);

public void add(int index, E element) {
        //對指定的索引進行校驗
        rangeCheckForAdd(index);
        //確定陣列的長度
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //將原陣列index索引之前的元素保留，index所以之後的元素全體像後移一位
        System.arraycopy(elementData, index, elementData, index + 1,
                size - index);
        //將element元素插入到陣列的index索引處
        elementData[index] = element;
        size++;
    }
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

3、一次向ArrayList中新增一個集合public boolean addAll(Collection

public boolean addAll(Collection<? extends E> c) {
        //將集合轉成物件陣列
        Object[] a = c.toArray();
        int numNew = a.length;
        //確定陣列是否需要擴容
        ensureCapacityInternal(size + numNew);
        //陣列複製
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

4、在指定索引處新增集合public boolean addAll(int index, Collection

public boolean addAll(int index, Collection<? extends E> c) {
        //檢查索引index是否合法
        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;
    }

5、刪除指定索引處的元素 public E remove(int index) 

public E remove(int index) {
        //檢查索引是否合法
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);
        //需要移動的元素的個數
        int numMoved = size - index - 1;
        if (numMoved > 0)
            //將index+1索引之後的所有元素向前移動一位
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
        //將最後一位的引用置空，等待GC回收，並將陣列的長度-1
        elementData[--size] = null; // clear to let GC do its work
        //將被刪除的值返回
        return oldValue;
    }

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

6、刪除指定的元素 public boolean remove(Object o)，與上面的邏輯相同。

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)
            //將index+1索引之後的所有元素向前移動一位
            System.arraycopy(elementData, index+1, elementData, index,
                    numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

7、刪除某個集合removeAll和retainAll兩個方法是相通的，區別在於removeAll(Collection

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

    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

觀察removeAll和retainAll的程式碼可發現，兩個方法的區別只是在呼叫刪除方法batchRemove時所傳的標誌位不同。batchRemove方法是根據方法第二個引數的值來判斷當前操作是進行刪除還是保留。

    /**
     * 該方法的主要邏輯為：
     * 遍歷陣列elementData，根據使用者傳入的判定條件，將符合條件的元素插入到elementData陣列的前面,
     * 最後再將其餘不符合規則的元素刪除。
     * @param c
     * @param complement
     * @return
     */
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        //r變數用於記錄遍歷elementData陣列的長度
        //w變數用於記錄符合條件(complement)的元素的索引
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                //將符合條件的元素插入到陣列的前面
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            //當c.contains(elementData[r])丟擲異常時執行
            if (r != size) {
                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;
    }

8、根據索引查詢 get(int index)

public E get(int index) {
       rangeCheck(index);

       return elementData(index);
}

9、據元素查詢其在集合中的索引 indexOf(Object o)和lastIndexOf(Object o)

//根據元素查詢其在集合中的索引（正向查詢），返回的是符合條件的第一個值的索引
   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;
       }
       //沒找到就返回-1
       return -1;
   }
//據元素查詢其在集合中的索引（反向查詢）
   public int lastIndexOf(Object o) {
       if (o == null) {
           for (int i = size-1; i >= 0; i--)
               if (elementData[i]==null)
                   return i;
       } else {
           for (int i = size-1; i >= 0; i--)
               if (o.equals(elementData[i]))
                   return i;
       }
       return -1;
   }

10、修改指定索引處的元素 set(int index, E element)

public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        //返回的是被替換的元素的值
        return oldValue;
}

11、其他的常用方法

public void clear() {
        modCount++;

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

        size = 0;
}
public boolean contains(Object o) {
        return indexOf(o) >= 0;
}
public boolean isEmpty() {
        return size == 0;
}
 public int size() {
        return size;
 }

相關推薦

ArrayList原始碼學習筆記------常用API

本文的原始碼來自於jdk1.8版本，然而並不會涉及jdk8新特性。 ArrayList簡介 ArrayList是基於陣列實現的，是一個動態陣列，其容量能自動增長，類似於C語言中的動態申請記憶體，動態增長記憶體。 ArrayList不是執行緒安全的，只能用在

Java第十五天學習筆記~常用物件API（Spring類特點、建構函式、常用方法）

常用物件API-----Spring類 一、特點 字串是一個特殊的物件 字串物件一旦被初始化就不會被改變 package day15; public class StringDemo { public static void main(String[] args)

MongoDB學習筆記—常用命令

upd 鍵值 操作 false doc cer 查看 數據庫 創建 這裏記錄一下MongoDB常用的命令 數據庫相關 創建數據庫 use DATABASE_NAME 如果數據庫不存在，則創建數據庫，否則切換到指定數據庫。 刪除數據庫：切換到要刪除的數據庫下，執行

Java學習筆記——常用類

per 自動拆箱 筆記 parse cte 基本數據類型 rap () In 字符串相關見string 包裝類（Wrapper Class）：lang包 將基本數據類型轉換成對象 除char->Character，int->Integer，別的首字母大寫 以

集合框架ArrayList+JAVA學習筆記-DAY16

15.01_集合框架(物件陣列的概述和使用) A:案例演示 需求：我有5個學生，請把這個5個學生的資訊儲存到陣列中，並遍歷陣列，獲取得到每一個學生資訊。 Student[] arr = new Student[5];

GIT學習筆記——常用命令

最近使用使用GIT較多，但命令很容易就忘記了，於是整理下，大多整理與一些文件和他人部落格 在當前目錄新建建一個純git程式碼庫 $ git --bare init 在當前目錄新建一個Git程式碼庫 $ git init 新建一個目錄，將其初始化為Git程式碼庫

JDK原始碼學習筆記——String

1、學習jdk原始碼，從以下幾個方面入手： 　　類定義（繼承，實現介面等） 　　全域性變數 　　方法 　　內部類 2、hashCode 　　private int hash; 　　public int hashCode() { int h = hash;

splash3.2學習筆記——HTTP API（2）

render.har     使用HAR格式返回Splash與網站互動的資訊。包含請求、響應、時間線、頭部資訊，等。     可以使用HAR Viewer顯示端點返回的視覺化資訊;與FIrefox和Chrome開發者工具中的"Netwo

splash3.2學習筆記——HTTP API（1）

    Splash是一個javascript渲染工具。是一款支援HTTP API的輕量級web瀏覽器，通過Python3的twisted和QT5實現。QT(twisted)反應器通過QT主迴圈充分利用webkit的併發優勢，使渲染服務完全非同步。SPlash的一些主要

nginx 原始碼學習筆記（二十一）—— event 模組(二) ——事件驅動核心ngx_process_events_and_timers

首先繼續回憶下，之前子執行緒執行操作裡面有一個未涉及的內容ngx_process_events_and_timers，今天我們就來研究下這個函式。 本篇文章來自於：http://blog.csdn.net/lengzijian/article/details/7601730 先來看一下第十九

Spring Cloud學習筆記18——API 閘道器

API 閘道器是一套主要用於統一API入口的應用元件，可以管理所有的API，形成一個API的入口 API閘道器的意義 集合多個API 統一API入口 API閘道器所帶來的好處 避免將內部資訊洩露給外部 為微服務新增額外的安全層 支

Underscore.js 原始碼學習筆記

版本 Underscore.js 1.9.1 一共 1693 行，一行行看吧，希望作者是正序寫的…… 註釋我就刪了…… 太長了……   整體是一個 (function() {...}());  這樣的東西，我們應該知道這是一個 IIFE（立即執行函式）。  

eos 原始碼學習筆記一

eos 原始碼學習筆記 1、eos 中的常見合約型別 newaccount setcode setabi updateauth deleteauth linkauth unlinkauth canc

Spring原始碼學習筆記 （一）bean是怎麼生成的

bean 實在 bean 重新整理過程中產生的，首先我們看下 bean 的重新整理方法。下面是 AbstractApplicationContext 的 refresh 方法。 @Override public void refresh() throws

spring 原始碼學習筆記（二）事務管理

spring 事務管理會幫我們自動管理資料庫的事務，沒讀原始碼前覺得很神祕，讀了原始碼發現原理還是很簡單的。 本質上還是用的 jdbc 的事務管理。spring 在呼叫某個方法前，判斷是否需要事務，如果需要，則呼叫 con.setAutoCommit(false);//開

Android原始碼學習筆記：Context、ActivityThread和Activity的生命週期

總結： ①在應用啟動的時候，首先會建立一個程序process，然後建立ActivityThread這個物件。 ②根據我們之前學習的Handler，可以知道，在ActivityThread的main方法中，會建立一個Looper和MessageQueue物件。 ③在建

Java學習筆記--常用類及其常用方法介紹

object類 直接輸出一個物件的名稱，其實就是呼叫了該物件的toString()方法。 一般會重寫toString()方法，輸出成員變數的值。 物件名.getClass().getname()會得到類名。 equals()方法預設是比較兩個物件的地址是否相

koa原始碼學習筆記

我們的koa程式可以簡化為以下三步 const app = new koa() app.use(middleware) app.listen(port) 搞清楚這三步分別做了什麼?讓我們翻開koa原始碼一看究竟.開啟node_modules/koa/packa

elasticsearch6.x官方文件學習筆記----Document API翻譯

開始之前先學習 副本         介紹：Elasticsearch的每個索引都被分成shard ，每個shard 可以有多個副本。這些副本稱為複製組，在新增或刪除文件時必須保持同步。如果我們不這樣做，從一個副本閱讀將會導致與從另

TBSchedule原始碼學習筆記-啟動過程 轉自https://blog.csdn.net/weiythi/article/details/78742651

TBSchedule基本概念及原理 概念介紹 TBSchedule是一個支援分散式的排程框架，能讓一種批量任務或者不斷變化的任務，被動態的分配到多個主機的JVM中，不同的執行緒組中並行執行。基於ZooKeeper的純Java實現，由Alibaba開源。 程式碼實