ArrayList集合的使用和源码详细分析
寫在前面：博主是一位普普通通的19屆雙非軟工在讀生，平時最大的愛好就是聽聽歌，逛逛B站。博主很喜歡的一句話花開堪折直須折，莫待無花空折枝：博主的理解是頭一次為人，就應該做自己想做的事，做自己不后悔的事，做自己以后不會留有遺憾的事，做自己覺得有意義的事，不浪費這大好的青春年華。博主寫博客目的是記錄所學到的知識并方便自己復習，在記錄知識的同時獲得部分瀏覽量，得到更多人的認可，滿足小小的成就感，同時在寫博客的途中結(jié)交更多志同道合的朋友，讓自己在技術(shù)的路上并不孤單。
本文轉(zhuǎn)載ArrayList(JDK1.8)源碼解析
目錄：
1.ArrayList概述
2.成員變量的源碼解析(JDK1.8)
3.構(gòu)造方法的源碼解析(JDK1.8)
4.內(nèi)部類源碼解析(JDK1.8)
5.add()方法源碼解析(JDK1.8)
6.數(shù)組擴容原理源碼解析(JDK1.8)
7.大數(shù)據(jù)插入問題
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和數(shù)組之間的轉(zhuǎn)換
16.多線程場景下使用ArrayList
17.ArrayList的優(yōu)缺點
1.ArrayList概述
1.1.ArrayList簡介
java.util.ArrayList集合數(shù)據(jù)存儲的結(jié)構(gòu)是數(shù)組結(jié)構(gòu)(它的底層原理其實就是一個Object數(shù)組)。元素增刪慢，查找快，由于日常開發(fā)中使用最多的功能為查詢數(shù)據(jù)、遍歷數(shù)據(jù)，所以ArrayList是最常用的集合。
1.2.ArrayList特點：
1.它是基于數(shù)組實現(xiàn)的List類
2.可以動態(tài)地調(diào)整容量
3.有序的（元素輸出順序與輸入順序一致）
4.元素可以為 null
5.不同步，非線程安全，效率高
6.查詢快，增刪慢
7.用空間更小，對比 LinkedList，不用占用額外空間維護鏈表結(jié)構(gòu)
2.成員變量的源碼解析
// 序列號 private static final long serialVersionUID = 8683452581122892189L; // 數(shù)組初始容量為 10 private static final int DEFAULT_CAPACITY = 10;0 // 空對象數(shù)組 private static final Object[] EMPTY_ELEMENTDATA = {}; // 缺省空對象數(shù)組，如果使用默認構(gòu)造方法創(chuàng)建對象內(nèi)容是該值 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 底層數(shù)據(jù)結(jié)構(gòu)，數(shù)組，當前對象存放的地方，當前對象不參與序列化 transient Object[] elementData; // 當前數(shù)組元素個數(shù)，默認為0 private int size; // 最大數(shù)組容量 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;注意看ArrayList 的 elementData 加上 transient 修飾可以這么解釋：
再看一下 ArrayList 的定義：
可以看到 ArrayList 實現(xiàn)了 Serializable 接口，這意味著 ArrayList 支持序列化。transient 的作用是說不希望 elementData 數(shù)組被序列化，重寫了 writeObject 實現(xiàn)：
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(); }每次序列化時，先調(diào)用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素，然后遍歷 elementData，只序列化已存入的元素，這樣既加快了序列化的速度，又減小了序列化之后的文件大小。
3.構(gòu)造方法的源碼解析
//默認構(gòu)造方法，初始為空數(shù)組。 //只有插入一條數(shù)據(jù)后才會擴展為10，而實際上默認是空的public ArrayList() {// 把空的對象數(shù)組賦給elementDatathis.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }//根據(jù)指定容量創(chuàng)建對象數(shù)組 public ArrayList(int initialCapacity) {if (initialCapacity > 0) {//創(chuàng)建initialCapacity大小的數(shù)組this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {//創(chuàng)建空數(shù)組this.elementData = EMPTY_ELEMENTDATA;} else {throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);} }/*** 構(gòu)造一個包含指定集合的元素的列表，按照它們由集合的迭代器返回的順序。*/ public ArrayList(Collection<? extends E> c) {//轉(zhuǎn)換最主要的是toArray()，這在Collection中就定義了elementData = c.toArray();//toArray返回一個數(shù)組if ((size = elementData.length) != 0) {// c.toArray 有可能不返回一個 Object 數(shù)組if (elementData.getClass() != Object[].class)//因為所有的Object數(shù)組共用一個Class文件//使用 Arrays.copy 方法拷創(chuàng)建一個 Object 數(shù)組elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// 替換為空數(shù)組this.elementData = EMPTY_ELEMENTDATA;} }為了理解所有的Object數(shù)組共用一個Class文件，我們隨機創(chuàng)建兩個Object數(shù)組：
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數(shù)組共用一個Class文件");}elseSystem.out.println("不同的Object數(shù)組不一定共用一個Class文件");} } 運行結(jié)果： 所有的Object數(shù)組共用一個Class文件4.內(nèi)部類源碼解析
(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有四個內(nèi)部類，其中的Itr是實現(xiàn)了Iterator接口，同時重寫了里面的hasNext()，next()， remove()等方法；其中的ListItr 繼承 Itr，實現(xiàn)了ListIterator接口，同時重寫了hasPrevious()， nextIndex()， previousIndex()，previous()， set(E e)，add(E e) 等方法，所以這也可以看出了 Iterator和ListIterator的區(qū)別：ListIterator在Iterator的基礎(chǔ)上增加了添加對象，修改對象，逆向遍歷等方法，這些是Iterator不能實現(xiàn)的。
5.add()方法源碼解析
//添加一個特定的元素到list的末尾 public boolean add(E e) {//先確保elementData數(shù)組的長度足夠，size是數(shù)組中數(shù)據(jù)的個數(shù)，因為要添加一個元素，所以size+1，先判斷size+1的這個個數(shù)數(shù)組能否放得下，在這個方法中去判斷數(shù)組長度是否夠用ensureCapacityInternal(size + 1); // Increments modCount!!//在數(shù)據(jù)中正確的位置上放上元素e，并且size++elementData[size++] = e;return true; }//在指定位置添加一個元素 public void add(int index, E element) {rangeCheckForAdd(index);//先確保elementData數(shù)組的長度足夠ensureCapacityInternal(size + 1); // Increments modCount!!//將數(shù)據(jù)整體向后移動一位，空出位置之后再插入，效率不太好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) {//把該集合轉(zhuǎn)為對象數(shù)組Object[] a = c.toArray();int numNew = a.length;//增加容量ensureCapacityInternal(size + numNew); // Increments modCount//挨個向后遷移System.arraycopy(a, 0, elementData, size, numNew);size += numNew;//新數(shù)組有元素，就返回 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;//原來的數(shù)組挨個向后遷移if (numMoved > 0)System.arraycopy(elementData, index, elementData, index + numNew,numMoved);//把新的集合數(shù)組 添加到指定位置System.arraycopy(a, 0, elementData, index, numNew);size += numNew;return numNew != 0; }我們主注意到其實元素的各種添加方式其實是依據(jù)System.arraycopy來實現(xiàn)
6.數(shù)組擴容原理源碼解析
//確保內(nèi)部容量夠用 private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); }//計算容量。判斷初始化的elementData是不是空的數(shù)組,如果是空的話，返回默認容量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數(shù)組的長度不夠用，不夠用那么就要增加elementData的length。這里有的小伙伴就會模糊minCapacity到底是什么呢，這里解釋一下/*** 當我們要 add 進第1個元素到 ArrayList 時，elementData.length 為0 （因為還是一個空的 list），因為執(zhí)行了 `ensureCapacityInternal()` 方法 ，所以 minCapacity 此時為10。此時，`minCapacity - elementData.length > 0 `成立，所以會進入 `grow(minCapacity)` 方法。* 當add第2個元素時，minCapacity 為2，此時e lementData.length(容量)在添加第一個元素后擴容成 10 了。此時，`minCapacity - elementData.length > 0 ` 不成立，所以不會進入 （執(zhí)行）`grow(minCapacity)` 方法。* 添加第3、4···到第10個元素時，依然不會執(zhí)行g(shù)row方法，數(shù)組容量都為10。* 直到添加第11個元素，minCapacity(為11)比elementData.length（為10）要大。進入grow方法進行擴容。*/// overflow-conscious codeif (minCapacity - elementData.length > 0)//ArrayList能自動擴展大小的關(guān)鍵方法就在這里了grow(minCapacity); }//擴容核心方法 private void grow(int minCapacity) {//將擴充前的elementData大小給oldCapacity// overflow-conscious codeint oldCapacity = elementData.length;//新容量newCapacity是1.5倍的舊容量oldCapacityint newCapacity = oldCapacity + (oldCapacity >> 1);//這句話就是適應于elementData就空數(shù)組的時候，length=0，那么oldCapacity=0，newCapacity=0，所以這個判斷成立，在這里就是真正的初始化elementData的大小了，就是為10。if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//如果newCapacity超過了最大的容量限制，就調(diào)用hugeCapacity，也就是將能給的最大值給newCapacityif (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//新的容量大小已經(jīng)確定好了，就copy數(shù)組，改變?nèi)萘看笮 ?/span>// 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 也就是說最大也就能給到第一個數(shù)值。還是超過了這個限制，就要溢出了。相當于arraylist給了兩層防護。return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE; }至此，我們徹底明白了ArrayList的擴容機制了。首先創(chuàng)建一個空數(shù)組elementData，第一次插入數(shù)據(jù)時直接擴充至10，然后如果elementData的長度不足，就擴充至1.5倍，如果擴充完還不夠，就使用需要的長度作為elementData的長度。
7.大數(shù)據(jù)問題
在遇到大量數(shù)據(jù)時還是會頻繁的拷貝數(shù)據(jù)。那么如何緩解這種問題呢，
ArrayList為我們提供了兩種可行的方案：
1.使用ArrayList(int initialCapacity)這個有參構(gòu)造，在創(chuàng)建時就聲明一個較大的大小，這樣解決了頻繁拷貝問題，但是需要我們提前預知數(shù)據(jù)的數(shù)量級，也會一直占有較大的內(nèi)存。
2.除了添加數(shù)據(jù)時可以自動擴容外，我們還可以在插入前先進行一次擴容。只要提前預知數(shù)據(jù)的數(shù)量級，就可以在需要時直接一次擴充到位，與ArrayList(int initialCapacity)相比的好處在于不必一直占有較大內(nèi)存，同時數(shù)據(jù)拷貝的次數(shù)也大大減少了。這個方法就是ensureCapacity(int minCapacity)，其內(nèi)部就是調(diào)用了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));} } 運行結(jié)果： 使用ensureCapacity方法前：2700 使用ensureCapacity方法后：1054通過運行結(jié)果，我們可以很明顯的看出向 ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以減少增量重新分配的次數(shù)
8.remove()方法源碼解析
//根據(jù)索引刪除指定位置的元素 public E remove(int index) {//檢查index的合理性rangeCheck(index);//這個作用很多，比如用來檢測快速失敗的一種標志。modCount++;//通過索引直接找到該元素E oldValue = elementData(index);//計算要移動的位數(shù)。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)方法的內(nèi)部跟remove(index)的實現(xiàn)幾乎一樣，這里最主要是知道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; }//內(nèi)部方法，“快速刪除”，就是把重復的代碼移到一個方法里 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用來控制循環(huán)，w是記錄有多少個交集int r = 0, w = 0;boolean modified = false;try {//遍歷 ArrayList 集合for (; r < size; r++)//參數(shù)中的集合c一次檢測集合A中的元素是否有if (c.contains(elementData[r]) == complement)//有的話，就給集合AelementData[w++] = elementData[r];} finally {//發(fā)生了異常，直接把 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，所以不能根據(jù)返回值來確認兩個集合是否有交集，而是通過原集合的大小是否發(fā)生改變來判斷，如果原集合中還有元素，則代表有交集，而元集合沒有元素了，說明兩個集合沒有交集。// 清除多余的元素，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++;//并沒有直接使數(shù)組指向 null,而是逐個把元素置為空，下次使用時就不用重新 new 了for (int i = 0; i < size; i++)elementData[i] = null;size = 0; }總結(jié)：根據(jù)索引刪除指定位置的元素，此時會把指定下標到數(shù)組末尾的元素挨個向前移動一個單位，并且會把數(shù)組最后一個元素設(shè)置為null，這樣是為了方便之后將整個數(shù)組不被使用時，會被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函數(shù)會檢查索引值是否合法（只檢查是否大于size，而沒有檢查是否小于0），值得注意的是，在get函數(shù)中存在element函數(shù)，element函數(shù)用于返回具體的元素，具體函數(shù)如下：
E elementData(int index) {return (E) elementData[index]; }說明：返回的值都經(jīng)過了向下轉(zhuǎn)型（Object -> E），這些是對我們應用程序屏蔽的小細節(jié)。
10.set()方法源碼解析
//設(shè)定指定下標索引的元素值 public E set(int index, E element) {// 檢驗索引是否合法rangeCheck(index);// 舊值E oldValue = elementData(index);// 賦新值elementData[index] = element;// 返回舊值return oldValue; }11.indexOf()方法源碼解析
// 從首開始查找數(shù)組里面是否存在指定元素 public int indexOf(Object o) {// 查找的元素為空if (o == null) { // 遍歷數(shù)組，找到第一個為空的元素，返回下標for (int i = 0; i < size; i++) if (elementData[i]==null)return i;} else { // 查找的元素不為空// 遍歷數(shù)組，找到第一個和指定元素相等的元素，返回下標for (int i = 0; i < size; i++) if (o.equals(elementData[i]))return i;} // 沒有找到，返回空return -1; }//返回列表中指定元素最后一次出現(xiàn)的索引，倒著遍歷 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元素的。與此函數(shù)對應的lastIndexOf，表示從尾部開始查找。
12.contains()方法源碼解析
//判斷是否含有某個元素 public boolean contains(Object o) {return indexOf(o) >= 0; }13.toArray()方法源碼解析
/**以正確的順序返回一個包含此列表中所有元素的數(shù)組（從第一個到最后一個元素）; 返回的數(shù)組的運行時類型是指定數(shù)組的運行時類型。 */ public Object[] toArray() {//elementData：要復制的數(shù)組；size：要復制的長度return Arrays.copyOf(elementData, size); }public <T> T[] toArray(T[] a) {//如果只是要把一部分轉(zhuǎn)換成數(shù)組if (a.length < size)// Make a new array of a's runtime type, but my contents:return (T[]) Arrays.copyOf(elementData, size, a.getClass());//全部元素拷貝到 數(shù)組 aSystem.arraycopy(elementData, 0, a, 0, size);if (a.length > size)a[size] = null;return a; }14.ArrayList三種遍歷方式
14.1.第一種for循環(huán)
基于計數(shù)器。在集合外部維護一個計數(shù)器，然后依次讀取每一個位置的元素，當讀取到最后一個元素后停止
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));}} } 運行結(jié)果： aaa bbb ccc ddd14.2.第二種foreach循環(huán)
foreach 內(nèi)部也是采用了 Iterator 的方式實現(xiàn)，使用時不需要顯式聲明 Iterator 或計數(shù)器。優(yōu)點是代碼簡潔，不易出錯；缺點是只能做簡單的遍歷，不能在遍歷過程中操作數(shù)據(jù)集合，例如刪除、替換。
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 ddd14.3.第三種迭代器Iterator
Iterator 是面向?qū)ο蟮囊粋€設(shè)計模式，目的是屏蔽不同數(shù)據(jù)集合的特點，統(tǒng)一遍歷集合的接口。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);}} } 運行結(jié)果： aaa bbb ccc ddd15ArrayList與數(shù)組之間相互轉(zhuǎn)換
數(shù)組轉(zhuǎn) List：使用 Arrays. asList(array) 進行轉(zhuǎn)換。
List 轉(zhuǎn)數(shù)組：使用 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類型數(shù)組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);}} } 運行結(jié)果： aaa bbb ccc ddd --------------------------------------------- aaa bbb ccc ddd16.多線程場景下使用ArrayList
ArrayList 不是線程安全的，如果遇到多線程場景，可以通過 Collections 的 synchronizedList 方法將其轉(zhuǎn)換成線程安全的容器后再使用。例如像下面這樣：
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的優(yōu)缺點
ArrayList優(yōu)點如下：
1.ArrayList 底層以數(shù)組實現(xiàn)，是一種隨機訪問模式。ArrayList 實現(xiàn)了 RandomAccess 接口，因此查找的時候非常快。
2.ArrayList 在順序添加一個元素的時候非常方便。
ArrayList 的缺點如下：
1.刪除元素的時候，需要做一次元素復制操作。如果要復制的元素很多，那么就會比較 耗費性能。
2.插入元素的時候，也需要做一次元素復制操作，缺點同上。
總結(jié)
以上是生活随笔為你收集整理的ArrayList集合的使用和源码详细分析的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Iterator和ListIterato
- 下一篇： System.arraycopy()和