寫在前面：博主是一位普普通通的19屆雙非軟工在讀生，平時最大的愛好就是聽聽歌，逛逛B站。博主很喜歡的一句話花開堪折直須折，莫待無花空折枝：博主的理解是頭一次為人，就應該做自己想做的事，做自己不后悔的事，做自己以后不會留有遺憾的事，做自己覺得有意義的事，不浪費這大好的青春年華。博主寫博客目的是記錄所學到的知識并方便自己復習，在記錄知識的同時獲得部分瀏覽量，得到更多人的認可，滿足小小的成就感，同時在寫博客的途中結交更多志同道合的朋友，讓自己在技術的路上并不孤單。

本文轉載ArrayList(JDK1.8)源碼解析

目錄：

1.ArrayList概述
2.成員變量的源碼解析(JDK1.8)
3.構造方法的源碼解析(JDK1.8)
4.內部類源碼解析(JDK1.8)
5.add()方法源碼解析(JDK1.8)
6.數組擴容原理源碼解析(JDK1.8)
7.大數據插入問題
8.remove()方法源碼解析(JDK1.8)
9.get()方法源碼解析(JDK1.8)
10.set()方法源碼解析(JDK1.8)
11.indexOf()方法源碼解析(JDK1.8)
12.contains()方法源碼解析(JDK1.8)
13.toArray()方法源碼解析(JDK1.8)
14.ArrayList集合的三種遍歷方式
15.ArrayList和數組之間的轉換
16.多線程場景下使用ArrayList
17.ArrayList的優缺點

1.ArrayList概述

1.1.ArrayList簡介

java.util.ArrayList集合數據存儲的結構是數組結構(它的底層原理其實就是一個Object數組)。元素增刪慢，查找快，由于日常開發中使用最多的功能為查詢數據、遍歷數據，所以ArrayList是最常用的集合。

1.2.ArrayList特點：

1.它是基于數組實現的List類
2.可以動態地調整容量
3.有序的（元素輸出順序與輸入順序一致）
4.元素可以為 null
5.不同步，非線程安全，效率高
6.查詢快，增刪慢
7.用空間更小，對比 LinkedList，不用占用額外空間維護鏈表結構

2.成員變量的源碼解析

// 序列號 private static final long serialVersionUID = 8683452581122892189L; // 數組初始容量為 10 private static final int DEFAULT_CAPACITY = 10;0 // 空對象數組 private static final Object[] EMPTY_ELEMENTDATA = {}; // 缺省空對象數組，如果使用默認構造方法創建對象內容是該值 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 底層數據結構，數組，當前對象存放的地方，當前對象不參與序列化 transient Object[] elementData; // 當前數組元素個數，默認為0 private int size; // 最大數組容量 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

注意看ArrayList 的 elementData 加上 transient 修飾可以這么解釋：
再看一下 ArrayList 的定義：

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

可以看到 ArrayList 實現了 Serializable 接口，這意味著 ArrayList 支持序列化。transient 的作用是說不希望 elementData 數組被序列化，重寫了 writeObject 實現：

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 array length*s.writeInt(elementData.length);*// 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(); }

每次序列化時，先調用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素，然后遍歷 elementData，只序列化已存入的元素，這樣既加快了序列化的速度，又減小了序列化之后的文件大小。

3.構造方法的源碼解析

//默認構造方法，初始為空數組。 //只有插入一條數據后才會擴展為10，而實際上默認是空的public ArrayList() {// 把空的對象數組賦給elementDatathis.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }//根據指定容量創建對象數組 public ArrayList(int initialCapacity) {if (initialCapacity > 0) {//創建initialCapacity大小的數組this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {//創建空數組this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);} }/*** 構造一個包含指定集合的元素的列表，按照它們由集合的迭代器返回的順序。*/ public ArrayList(Collection<? extends E> c) {//轉換最主要的是toArray()，這在Collection中就定義了elementData = c.toArray();//toArray返回一個數組if ((size = elementData.length) != 0) {// c.toArray 有可能不返回一個 Object 數組if (elementData.getClass() != Object[].class)//因為所有的Object數組共用一個Class文件//使用 Arrays.copy 方法拷創建一個 Object 數組elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// 替換為空數組this.elementData = EMPTY_ELEMENTDATA;} }

為了理解所有的Object數組共用一個Class文件，我們隨機創建兩個Object數組：

package untl; public class MyObject {public static void main(String[] args) {Object arr []=new Object[10];Object brr []=new Object[20];if(arr.getClass()==brr.getClass()){System.out.println("所有的Object數組共用一個Class文件");}elseSystem.out.println("不同的Object數組不一定共用一個Class文件");} } 運行結果： 所有的Object數組共用一個Class文件

4.內部類源碼解析

(1)private class Itr implements Iterator<E> (2)private class ListItr extends Itr implements ListIterator<E> (3)private class SubList extends AbstractList<E> implements RandomAccess (4)static final class ArrayListSpliterator<E> implements Spliterator<E>

我們只需要掌握兩個迭代器就行

ArrayList有四個內部類，其中的Itr是實現了Iterator接口，同時重寫了里面的hasNext()，next()， remove()等方法；其中的ListItr 繼承 Itr，實現了ListIterator接口，同時重寫了hasPrevious()， nextIndex()， previousIndex()，previous()， set(E e)，add(E e) 等方法，所以這也可以看出了 Iterator和ListIterator的區別：ListIterator在Iterator的基礎上增加了添加對象，修改對象，逆向遍歷等方法，這些是Iterator不能實現的。

5.add()方法源碼解析

//添加一個特定的元素到list的末尾 public boolean add(E e) {//先確保elementData數組的長度足夠，size是數組中數據的個數，因為要添加一個元素，所以size+1，先判斷size+1的這個個數數組能否放得下，在這個方法中去判斷數組長度是否夠用ensureCapacityInternal(size + 1); // Increments modCount!!//在數據中正確的位置上放上元素e，并且size++elementData[size++] = e;return true; }//在指定位置添加一個元素 public void add(int index, E element) {rangeCheckForAdd(index);//先確保elementData數組的長度足夠ensureCapacityInternal(size + 1); // Increments modCount!!//將數據整體向后移動一位，空出位置之后再插入，效率不太好System.arraycopy(elementData, index, elementData, index + 1,size - index);elementData[index] = element;size++; }// 校驗插入位置是否合理 private void rangeCheckForAdd(int index) {//插入的位置肯定不能大于size 和小于0if (index > size || index < 0) //如果是，就報越界異常throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }//添加一個集合 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;//新數組有元素，就返回 truereturn 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 modCountint 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; }

我們主注意到其實元素的各種添加方式其實是依據System.arraycopy來實現

6.數組擴容原理源碼解析

//確保內部容量夠用 private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); }//計算容量。判斷初始化的elementData是不是空的數組,如果是空的話，返回默認容量10與minCapacity=size+1的較大值者。 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++;//minCapacity如果大于了實際elementData的長度，那么就說明elementData數組的長度不夠用，不夠用那么就要增加elementData的length。這里有的小伙伴就會模糊minCapacity到底是什么呢，這里解釋一下/*** 當我們要 add 進第1個元素到 ArrayList 時，elementData.length 為0 （因為還是一個空的 list），因為執行了 `ensureCapacityInternal()` 方法 ，所以 minCapacity 此時為10。此時，`minCapacity - elementData.length > 0 `成立，所以會進入 `grow(minCapacity)` 方法。* 當add第2個元素時，minCapacity 為2，此時e lementData.length(容量)在添加第一個元素后擴容成 10 了。此時，`minCapacity - elementData.length > 0 ` 不成立，所以不會進入 （執行）`grow(minCapacity)` 方法。* 添加第3、4···到第10個元素時，依然不會執行grow方法，數組容量都為10。* 直到添加第11個元素，minCapacity(為11)比elementData.length（為10）要大。進入grow方法進行擴容。*/// overflow-conscious codeif (minCapacity - elementData.length > 0)//ArrayList能自動擴展大小的關鍵方法就在這里了grow(minCapacity); }//擴容核心方法 private void grow(int minCapacity) {//將擴充前的elementData大小給oldCapacity// overflow-conscious codeint oldCapacity = elementData.length;//新容量newCapacity是1.5倍的舊容量oldCapacityint newCapacity = oldCapacity + (oldCapacity >> 1);//這句話就是適應于elementData就空數組的時候，length=0，那么oldCapacity=0，newCapacity=0，所以這個判斷成立，在這里就是真正的初始化elementData的大小了，就是為10。if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//如果newCapacity超過了最大的容量限制，就調用hugeCapacity，也就是將能給的最大值給newCapacityif (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//新的容量大小已經確定好了，就copy數組，改變容量大小。// 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) // overflowthrow new OutOfMemoryError();//如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之將MAX_ARRAY_SIZE返回。因為maxCapacity是三倍的minCapacity，可能擴充的太大了，就用minCapacity來判斷了。//Integer.MAX_VALUE:2147483647 MAX_ARRAY_SIZE：2147483639 也就是說最大也就能給到第一個數值。還是超過了這個限制，就要溢出了。相當于arraylist給了兩層防護。return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE; }

至此，我們徹底明白了ArrayList的擴容機制了。首先創建一個空數組elementData，第一次插入數據時直接擴充至10，然后如果elementData的長度不足，就擴充至1.5倍，如果擴充完還不夠，就使用需要的長度作為elementData的長度。

7.大數據問題

在遇到大量數據時還是會頻繁的拷貝數據。那么如何緩解這種問題呢，
ArrayList為我們提供了兩種可行的方案：

1.使用ArrayList(int initialCapacity)這個有參構造，在創建時就聲明一個較大的大小，這樣解決了頻繁拷貝問題，但是需要我們提前預知數據的數量級，也會一直占有較大的內存。
2.除了添加數據時可以自動擴容外，我們還可以在插入前先進行一次擴容。只要提前預知數據的數量級，就可以在需要時直接一次擴充到位，與ArrayList(int initialCapacity)相比的好處在于不必一直占有較大內存，同時數據拷貝的次數也大大減少了。這個方法就是ensureCapacity(int minCapacity)，其內部就是調用了ensureCapacityInternal(int minCapacity)

舉個例子看兩者的效率：

public class EnsureCapacityTest {public static void main(String[] args) {ArrayList<Object> list = new ArrayList<Object>();final int N = 10000000;long startTime = System.currentTimeMillis();for (int i = 0; i < N; i++) {list.add(i);}long endTime = System.currentTimeMillis();System.out.println("使用ensureCapacity方法前：" + (endTime - startTime));list = new ArrayList<Object>();long startTime1 = System.currentTimeMillis();list.ensureCapacity(N);for (int i = 0; i < N; i++) {list.add(i);}long endTime1 = System.currentTimeMillis();System.out.println("使用ensureCapacity方法后：" + (endTime1 - startTime1));} } 運行結果： 使用ensureCapacity方法前：2700 使用ensureCapacity方法后：1054

通過運行結果，我們可以很明顯的看出向 ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以減少增量重新分配的次數

8.remove()方法源碼解析

//根據索引刪除指定位置的元素 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; }//從此列表中刪除指定元素的第一個匹配項，如果存在，則刪除。通過元素來刪除該元素，就依次遍歷，如果有這個元素，就將該元素的索引傳給fastRemobe(index)，使用這個方法來刪除該元素，fastRemove(index)方法的內部跟remove(index)的實現幾乎一樣，這里最主要是知道arrayList可以存儲null值 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 }//刪除或者保留指定集合中的元素 //用于兩個方法，一個removeAll()：它只清除指定集合中的元素，retainAll()用來測試兩個集合是否有交集。　 private boolean batchRemove(Collection<?> c, boolean complement) {//將原集合，記名為Afinal Object[] elementData = this.elementData;//r用來控制循環，w是記錄有多少個交集int r = 0, w = 0;boolean modified = false;try {//遍歷 ArrayList 集合for (; r < size; r++)//參數中的集合c一次檢測集合A中的元素是否有if (c.contains(elementData[r]) == complement)//有的話，就給集合AelementData[w++] = elementData[r];} finally {//發生了異常，直接把 r 后面的復制到 w 后面if (r != size) {//將剩下的元素都賦值給集合ASystem.arraycopy(elementData, r,elementData, w,size - r);w += size - r;}if (w != size) {//這里有兩個用途，在removeAll()時，w一直為0，就直接跟clear一樣，全是為null。//retainAll()：沒有一個交集返回true，有交集但不全交也返回true，而兩個集合相等的時候，返回false，所以不能根據返回值來確認兩個集合是否有交集，而是通過原集合的大小是否發生改變來判斷，如果原集合中還有元素，則代表有交集，而元集合沒有元素了，說明兩個集合沒有交集。// 清除多余的元素，clear to let GC do its workfor (int i = w; i < size; i++)elementData[i] = null;modCount += size - w;size = w;modified = true;}}return modified; }//保留公共的 public boolean retainAll(Collection<?> c) {Objects.requireNonNull(c);return batchRemove(c, true); }//將elementData中每個元素都賦值為null，等待垃圾回收將這個給回收掉 public void clear() {modCount++;//并沒有直接使數組指向 null,而是逐個把元素置為空，下次使用時就不用重新 new 了for (int i = 0; i < size; i++)elementData[i] = null;size = 0; }

總結：根據索引刪除指定位置的元素，此時會把指定下標到數組末尾的元素挨個向前移動一個單位，并且會把數組最后一個元素設置為null，這樣是為了方便之后將整個數組不被使用時，會被GC，可以作為小的技巧使用。

9.get()方法源碼解析

public E get(int index) {// 檢驗索引是否合法rangeCheck(index);return elementData(index); }private void rangeCheck(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }

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

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

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

10.set()方法源碼解析

//設定指定下標索引的元素值 public E set(int index, E element) {// 檢驗索引是否合法rangeCheck(index);// 舊值E oldValue = elementData(index);// 賦新值elementData[index] = element;// 返回舊值return oldValue; }

11.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; }//返回列表中指定元素最后一次出現的索引，倒著遍歷 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; }

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

12.contains()方法源碼解析

//判斷是否含有某個元素 public boolean contains(Object o) {return indexOf(o) >= 0; }

13.toArray()方法源碼解析

/**以正確的順序返回一個包含此列表中所有元素的數組（從第一個到最后一個元素）; 返回的數組的運行時類型是指定數組的運行時類型。 */ public Object[] toArray() {//elementData：要復制的數組；size：要復制的長度return Arrays.copyOf(elementData, size); }public <T> T[] toArray(T[] a) {//如果只是要把一部分轉換成數組if (a.length < size)// Make a new array of a's runtime type, but my contents:return (T[]) Arrays.copyOf(elementData, size, a.getClass());//全部元素拷貝到 數組 aSystem.arraycopy(elementData, 0, a, 0, size);if (a.length > size)a[size] = null;return a; }

14.ArrayList三種遍歷方式

14.1.第一種for循環

基于計數器。在集合外部維護一個計數器，然后依次讀取每一個位置的元素，當讀取到最后一個元素后停止

package untl; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class MyObject {public static void main(String[] args) {List<String> list=new ArrayList();Collections.addAll(list,"aaa","bbb","ccc","ddd");for (int i = 0; i <list.size() ; i++) {System.out.println(list.get(i));}} } 運行結果： aaa bbb ccc ddd

14.2.第二種foreach循環

foreach 內部也是采用了 Iterator 的方式實現，使用時不需要顯式聲明 Iterator 或計數器。優點是代碼簡潔，不易出錯；缺點是只能做簡單的遍歷，不能在遍歷過程中操作數據集合，例如刪除、替換。

package untl; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class MyObject {public static void main(String[] args) {List<String> list=new ArrayList();Collections.addAll(list,"aaa","bbb","ccc","ddd");for (String str:list) {System.out.println(str);}} } aaa bbb ccc ddd

14.3.第三種迭代器Iterator

Iterator 是面向對象的一個設計模式，目的是屏蔽不同數據集合的特點，統一遍歷集合的接口。Java 在 Collections 中支持了 Iterator 模式。

package untl; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; public class MyObject {public static void main(String[] args) {List<String> list=new ArrayList();Collections.addAll(list,"aaa","bbb","ccc","ddd");for (Iterator<String> iterator=list.iterator();iterator.hasNext();){String str=iterator.next();System.out.println(str);}} } 運行結果： aaa bbb ccc ddd

15ArrayList與數組之間相互轉換

數組轉 List：使用 Arrays. asList(array) 進行轉換。
List 轉數組：使用 List 自帶的 toArray() 方法。

例子：

package untl; import java.util.*; public class MyObject {public static void main(String[] args) {List<String> list1=new ArrayList<String>();Collections.addAll(list1,"aaa","bbb","ccc","ddd");Object arr[] = list1.toArray();//這里返回Object類型數組for (Object str:arr){System.out.println(str);}System.out.println("---------------------------------------------");List list2= Arrays.asList(arr);for (Iterator<String> iterator=list2.iterator();iterator.hasNext();){String str=iterator.next();System.out.println(str);}} } 運行結果： aaa bbb ccc ddd --------------------------------------------- aaa bbb ccc ddd

16.多線程場景下使用ArrayList

ArrayList 不是線程安全的，如果遇到多線程場景，可以通過 Collections 的 synchronizedList 方法將其轉換成線程安全的容器后再使用。例如像下面這樣：

List<String> synchronizedList = Collections.synchronizedList(list); synchronizedList.add("aaa"); synchronizedList.add("bbb"); for (int i = 0; i < synchronizedList.size(); i++) {System.out.println(synchronizedList.get(i)); }

17.ArrayList的優缺點

ArrayList優點如下：

1.ArrayList 底層以數組實現，是一種隨機訪問模式。ArrayList 實現了 RandomAccess 接口，因此查找的時候非常快。
2.ArrayList 在順序添加一個元素的時候非常方便。

ArrayList 的缺點如下：

1.刪除元素的時候，需要做一次元素復制操作。如果要復制的元素很多，那么就會比較 耗費性能。
2.插入元素的時候，也需要做一次元素復制操作，缺點同上。

總結

以上是生活随笔為你收集整理的ArrayList集合的使用和源码详细分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。