寫(xiě)在前面

作為Android開(kāi)發(fā)者，Java集合可能是開(kāi)發(fā)中最常使用的類(lèi)之一了。但很多人可能跟我一樣，對(duì)Java集合只停留在“使用”的層面上，而對(duì)其的實(shí)現(xiàn)、原理如何只是略知一二，所以有時(shí)可能忽略了一些小細(xì)節(jié)。這些細(xì)節(jié)可能對(duì)項(xiàng)目的整體性能影響不大，但我覺(jué)得，要成為一個(gè)好的程序員，必須要精益求精，對(duì)代碼性能“錙銖必較”。

舉個(gè)例子，各位在創(chuàng)建ArrayList實(shí)例時(shí)有沒(méi)有想過(guò)到底要不要指定其初始容量？指定了會(huì)怎樣？不指定又會(huì)怎樣？如果你跟博主我有同樣的困惑，那么本文一定能給你個(gè)滿(mǎn)意的答案！

正文

這篇文章是關(guān)于Java集合之一的List的，但不妨先祭上一張經(jīng)典的Java集合框架圖，先大概了解下Java集合整體的框架：

如果之前沒(méi)見(jiàn)過(guò)圖2.1的童鞋緊張了，這么多類(lèi)呀！別慌，圖2.1很多是接口和抽象類(lèi)，并且我們常使用的集合類(lèi)也就那么幾個(gè)，我們只關(guān)心我們經(jīng)常使用的即可，不常用的就暫時(shí)忽略，等用到了再看就行了。

好了，上面關(guān)于Java集合List的類(lèi)不多，我整理了下：

從圖2.2可以看到，我們經(jīng)常使用的Arrayist、LinkedList繼承的關(guān)系挺復(fù)雜的，但繼承的都是接口或抽象類(lèi)。而Collection和List是接口，Collection接口定義了集合的通用方法，和List接口是在Collection基礎(chǔ)上補(bǔ)充了專(zhuān)屬于List的通用方法。我們什么時(shí)候使用抽象類(lèi)？很多情況是為子類(lèi)提供共同的方法實(shí)現(xiàn)或?qū)傩詴r(shí)會(huì)使用抽象類(lèi)。所以就不難理解AbstractColection和AbstractList的作用了，當(dāng)然，你也可以繼承于它們實(shí)現(xiàn)自己的List，而這是題外話(huà)了，這里就不加討論了，下面我們進(jìn)入正題吧。

本文將介紹下面List子類(lèi)的一些細(xì)節(jié)：

• ArrayList
• Vector和Stack
• LinkedList
• SynchronizedList

ArrayLIst的細(xì)節(jié)

細(xì)節(jié)1：ArrayList基于數(shù)組實(shí)現(xiàn)，訪問(wèn)元素效率快，插入刪除元素效率慢

ArrayList是基于數(shù)組實(shí)現(xiàn)的，這個(gè)似乎不是什么秘密了，但為了文章的完整性，還是要介紹下。ArrayList內(nèi)部維護(hù)一個(gè)數(shù)組elementData，用于保存列表元素，基于數(shù)組的數(shù)組這數(shù)據(jù)結(jié)構(gòu)，我們知道，其索引元素是非常快的：

public E get(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));return (E) elementData[index]; // 索引無(wú)需遍歷，效率非常高！ } 復(fù)制代碼public E set(int index, E element) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));E oldValue = (E) elementData[index];elementData[index] = element; // 索引無(wú)需遍歷，效率非常高！return oldValue; } 復(fù)制代碼

可以看到，get、set直接根據(jù)索引獲取了目標(biāo)元素，中間不用做任何的遍歷操作，效率是非常快的。但是對(duì)于插入和刪除操作效率就不太理想了：

public void add(int index, E element) {if (index > size || index < 0)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));ensureCapacityInternal(size + 1); // 先判斷是否需要擴(kuò)容System.arraycopy(elementData, index, elementData, index + 1, // 把index后面的元素都向后偏移一位size - index);elementData[index] = element;size++; } 復(fù)制代碼

從插入操作的源碼可以看到，插入前，要先判斷是否需要擴(kuò)容（擴(kuò)容后面會(huì)講，這里先跳過(guò)），然后把Index后面的元素都偏移一位，這里的偏移是需要把元素復(fù)制后，再賦值當(dāng)前元素的后一索引的位置。顯然，這樣一來(lái)，插入一個(gè)元素，牽連到多個(gè)元素，效率自然就低了。再來(lái)看看刪除操作：

public E remove(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));modCount++;E oldValue = (E) elementData[index];int numMoved = size - index - 1;if (numMoved > 0) {// 把index后面的元素向前偏移一位，填補(bǔ)刪除的元素System.arraycopy(elementData, index + 1, elementData, index,numMoved);}elementData[--size] = null; // clear to let GC do its workreturn oldValue; } 復(fù)制代碼

同樣，刪除一個(gè)元素，需要把index后面的元素向前偏移一位，填補(bǔ)刪除的元素，也是牽連了多個(gè)元素。所以大家在使用時(shí)要謹(jǐn)慎了！

細(xì)節(jié)2：ArrayList支持快速隨機(jī)訪問(wèn)

什么是隨機(jī)訪問(wèn)？我們不防先來(lái)看看ArrayList的類(lèi)定義：

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable 復(fù)制代碼

看到RandomAccess了嗎，這個(gè)就是支持快速隨機(jī)訪問(wèn)的標(biāo)記，我們?cè)冱c(diǎn)進(jìn)去看看其源碼：

/*** ...* <p>It is recognized that the distinction between random and sequential* access is often fuzzy. For example, some <tt>List</tt> implementations* provide asymptotically linear access times if they get huge, but constant* access times in practice. Such a <tt>List</tt> implementation* should generally implement this interface. As a rule of thumb, a* <tt>List</tt> implementation should implement this interface if,* for typical instances of the class, this loop:* <pre>* for (int i=0, n=list.size(); i &lt; n; i++)* list.get(i);* </pre>* runs faster than this loop:* <pre>* for (Iterator i=list.iterator(); i.hasNext(); )* i.next();* </pre>* ...*/ public interface RandomAccess { } 復(fù)制代碼

額，是一個(gè)接口，沒(méi)有任何的屬性或方法定義。其實(shí)它只是一個(gè)標(biāo)記，繼承于它就相當(dāng)于告訴別人，我支持快速隨機(jī)訪問(wèn)，上面代碼我特意留下部分的注釋說(shuō)明，其中關(guān)鍵的部分在說(shuō)，通常情況下，使用索引訪問(wèn)的效率比使用迭代器訪問(wèn)的效率快！

我們把目光暫時(shí)轉(zhuǎn)移到Collections類(lèi)下，其中有很多基于是否有繼承于RandomAccess的List做不同的算法選擇判斷，我們來(lái)看其中的二分查找算法：

public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) {if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)// 當(dāng)List實(shí)現(xiàn)了RandomAccess或小于一定閥值時(shí)，使用索引二分查找算法return Collections.indexedBinarySearch(list, key);elsereturn Collections.iteratorBinarySearch(list, key); } 復(fù)制代碼

所以快速隨機(jī)訪問(wèn)是針對(duì)于Collections中的方法而言的（其他類(lèi)是否也有？歡迎大神們補(bǔ)充），支持快速隨機(jī)訪問(wèn)時(shí)，就選擇索引訪問(wèn)，效率會(huì)很快。

另外，從上面的二分查找算法我們又能得到一個(gè)提高效率的小細(xì)節(jié)：我們知道List是提供了IndexOf和lastIndexOf方法來(lái)檢索元素的，它們分別是從頭和尾開(kāi)始，一個(gè)一個(gè)比較的，那么顯然，使用Collections#binarySearch在大多數(shù)情況效率會(huì)比 IndexOf和lastIndexOf更快～

細(xì)節(jié)3：大多數(shù)情況下，我們都應(yīng)該指定ArrayList的初始容量

如果說(shuō)上面所介紹的細(xì)節(jié)大部分童鞋都知道，那這個(gè)細(xì)節(jié)相信很多人都不知道，包括在看源碼之前的我。在講為什么之前，我們需要先來(lái)了解ArrayList的擴(kuò)容機(jī)制。

ArrayList每次擴(kuò)容至少為原來(lái)容量大小的1.5倍，其默認(rèn)容量是10，當(dāng)你不為其指定初始容量時(shí)，它就會(huì)創(chuàng)建默認(rèn)容量大小為10的數(shù)組：

// 默認(rèn)最小容量 private static final int DEFAULT_CAPACITY = 10;// 空數(shù)組 private static final Object[] EMPTY_ELEMENTDATA = {};// 默認(rèn)容量空數(shù)組，可以理解為一個(gè)標(biāo)記 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};// 指定最小容量創(chuàng)建列表 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);} }// 創(chuàng)建默認(rèn)空列表 public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // 默認(rèn)容量空數(shù)組 } 復(fù)制代碼

我們經(jīng)常使用ArrayList的默認(rèn)構(gòu)造函數(shù)來(lái)創(chuàng)建實(shí)例，等等，不是說(shuō)不指定初始容量會(huì)創(chuàng)建默認(rèn)容量大小為10的數(shù)組嗎？但這里只賦值了空數(shù)組。是的，還記得我們上面分析的add源碼有個(gè)擴(kuò)容操作嗎？如果使用默認(rèn)構(gòu)造函數(shù)來(lái)創(chuàng)建實(shí)例，在第一次添加元素時(shí)，就會(huì)進(jìn)行擴(kuò)容，擴(kuò)容到默認(rèn)容量10的數(shù)組：

// 每次添加元素都會(huì)調(diào)用 private void ensureCapacityInternal(int minCapacity) {if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {// 如果為默認(rèn)容量空數(shù)組的話(huà)，添加元素時(shí)，至少擴(kuò)容到默認(rèn)最小容量minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}ensureExplicitCapacity(minCapacity); }private void ensureExplicitCapacity(int minCapacity) {modCount++;// overflow-conscious codeif (minCapacity - elementData.length > 0) // 大于當(dāng)前容量就擴(kuò)容grow(minCapacity); }// 擴(kuò)容 private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍原來(lái)大小// 先嘗試擴(kuò)容到1.5倍原來(lái)容量的大小，如果比用戶(hù)指定的大，那么就擴(kuò)容1.5倍// 否則擴(kuò)容用戶(hù)指定的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); } 復(fù)制代碼

所謂“擴(kuò)容”就是創(chuàng)建一個(gè)長(zhǎng)度更大的數(shù)組，再把舊數(shù)組的元素全部賦值到新數(shù)組。顯然，這個(gè)操作效率也是不理想的。雖然使用默認(rèn)構(gòu)造函數(shù)創(chuàng)建的實(shí)例，在第一次添加元素的擴(kuò)容并沒(méi)有元素復(fù)制，但還是要另外創(chuàng)建一個(gè)數(shù)組，并且是大小為10的數(shù)組，可能你并不需要這么大的數(shù)組，可能是3，可能是5，那么我們?yōu)楹尾灰婚_(kāi)始就指定其容量呢？

指定初始容量的方法也很簡(jiǎn)單，我們使用帶int參數(shù)的構(gòu)造函數(shù)就可以了：

// 指定最小容量創(chuàng)建列表 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);} } 復(fù)制代碼

或者有童鞋會(huì)說(shuō)，使用ensureCapacity指定容量也行，其實(shí)不然，為何ensureCapacity對(duì)容量大小有限制：

// 指定最小容量 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;// 指定最小容量成功的情況// 1.使用 new ArrayList() 創(chuàng)建實(shí)例并添加元素前，指定容量大小不能小于默認(rèn)容量10// 2.列表已存在元素，指定容量大小不能小于當(dāng)前容量大小if (minCapacity > minExpand) {ensureExplicitCapacity(minCapacity);} } 復(fù)制代碼

所以講到這，相信大家有答案了，為什么創(chuàng)建ArrayList要指定其初始容量？顯然我們是不希望它進(jìn)行耗時(shí)的擴(kuò)容操作，并且能在我們預(yù)知的情況下盡量使用大小剛剛好的列表，而不浪費(fèi)任何資源。 那么我們可以得到以下經(jīng)驗(yàn)：

• 都不應(yīng)該使用默認(rèn)構(gòu)造函數(shù)創(chuàng)建實(shí)例，以免自動(dòng)擴(kuò)容到默認(rèn)最小容量（10）
• 當(dāng)列表容量確定，應(yīng)該指定容量的方式創(chuàng)建實(shí)例
• 當(dāng)列表容量不確定時(shí)，可以預(yù)估我們將有會(huì)多少元素，指定稍大于預(yù)估值的容量

Vector和Stack的細(xì)節(jié)

Vector和Stack我們幾乎是不使用的了，所以并不打算用大篇幅來(lái)介紹，我們大概了解下就可以了。但我們可以探索下他們?yōu)楹尾皇艽?jiàn)，從而引以為戒。

細(xì)節(jié)1：Vector也是基于數(shù)組實(shí)現(xiàn)，同樣支持快速訪問(wèn)，并且線程安全

因?yàn)楦鶤rrayList一樣，都是基于數(shù)組實(shí)現(xiàn)，所以ArrayList具有的優(yōu)勢(shì)和劣勢(shì)Vector同樣也有，只是Vector在每個(gè)方法都加了同步鎖，所以它是線程安全的。但我們知道，同步會(huì)大大影響效率的，所以在不需要同步的情況下，Vector的效率就不如ArrayList了。所以我們?cè)诓恍枰降那闆r下，優(yōu)先選擇ArrayList；而在需要同步的情況下，也不是使用Vector，而是使用SynchronizedList（后面講到）。你看，Vector處于一個(gè)很尷尬的地步。但我個(gè)人覺(jué)得，Vector被遺棄的最大原因不在于它線程同步影響效率——因?yàn)檫@畢竟能在多線程環(huán)境下使用——而在于它的擴(kuò)容機(jī)制上。

細(xì)節(jié)2：Vector的擴(kuò)容機(jī)制不完善

Vector默認(rèn)容量也是10，跟ArrayList不同的是，Vector每次擴(kuò)容的大小是可以指定的，如果不指定，每次擴(kuò)容原來(lái)容量大小的2倍：

protected Object[] elementData; // 元素?cái)?shù)組protected int elementCount; // 元素?cái)?shù)量protected int capacityIncrement; // 擴(kuò)容大小public Vector(int initialCapacity, int capacityIncrement) {super();if (initialCapacity < 0)throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);this.elementData = new Object[initialCapacity];this.capacityIncrement = capacityIncrement; }public Vector(int initialCapacity) {this(initialCapacity, 0); // 默認(rèn)擴(kuò)容大小為0，那么擴(kuò)容時(shí)會(huì)增大兩倍 }public Vector() {this(10); // 默認(rèn)容量為10 }public synchronized void ensureCapacity(int minCapacity) {if (minCapacity > 0) {modCount++;ensureCapacityHelper(minCapacity);} }private void ensureCapacityHelper(int minCapacity) {// overflow-conscious codeif (minCapacity - elementData.length > 0) // 大于當(dāng)前容量就擴(kuò)容grow(minCapacity); }private void grow(int minCapacity) {// overflow-conscious codeint oldCapacity = elementData.length;int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity); // 默認(rèn)擴(kuò)容兩倍if (newCapacity - minCapacity < 0)newCapacity = minCapacity;if (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);elementData = Arrays.copyOf(elementData, newCapacity); } 復(fù)制代碼

另外需要提醒注意的是，不像ArrayList，如果是用Vector的默認(rèn)構(gòu)造函數(shù)創(chuàng)建實(shí)例，那么第一次添加元素就需要擴(kuò)容，但不會(huì)擴(kuò)容到默認(rèn)容量10，只會(huì)根據(jù)用戶(hù)指定或兩倍的大小擴(kuò)容。所以使用Vector時(shí)指不指定擴(kuò)容大小都很尷尬：

• 如果容量大小和擴(kuò)容大小都不指定，開(kāi)始可能會(huì)頻繁地進(jìn)行擴(kuò)容
• 如果指定了容量大小不指定擴(kuò)容大小，以2倍的大小擴(kuò)容會(huì)浪費(fèi)很多資源
• 如果指定了擴(kuò)容大小，擴(kuò)容大小就固定了，不管數(shù)組多大，都按這大小來(lái)擴(kuò)容，那么這個(gè)擴(kuò)容大小的取值總有不理想的時(shí)候

從Vector我們也可以反觀ArrayList設(shè)計(jì)巧妙的地方，這也許是Vector存在的唯一價(jià)值了哈哈。

細(xì)節(jié)3：Stack繼承于Vector，在其基礎(chǔ)上擴(kuò)展了棧的方法

Stack我們也不使用了，它只是添加多幾個(gè)棧常用的方法（這個(gè)LinkedList也有，后面討論），簡(jiǎn)單來(lái)看下它們的實(shí)現(xiàn)吧：

// 進(jìn)棧 public E push(E item) {addElement(item);return item; }// 出棧 public synchronized E pop() {E obj;int len = size();obj = peek();removeElementAt(len - 1);return obj; }public synchronized E peek() {int len = size();if (len == 0)throw new EmptyStackException();return elementAt(len - 1); } 復(fù)制代碼

LinkedList的細(xì)節(jié)

再來(lái)看看我們熟悉的LinkedList的細(xì)節(jié)～

細(xì)節(jié)1：LinkedList基于鏈表實(shí)現(xiàn)，插入刪除元素效率快，訪問(wèn)元素效率慢

LinkedList內(nèi)部維護(hù)一個(gè)雙端鏈表，可以從頭開(kāi)始檢索，也可以從尾開(kāi)始檢索。同樣的，得益于鏈表這一數(shù)據(jù)結(jié)構(gòu)，LinkedList在插入和刪除元素效率非常快。

插入元素只需新建一個(gè)node，再把前后指針指向?qū)?yīng)的前后元素即可：

// 鏈尾追加 void linkLast(E e) {final Node<E> l = last;final Node<E> newNode = new Node<>(l, e, null);last = newNode;if (l == null)first = newNode;elsel.next = newNode;size++;modCount++; }// 指定節(jié)點(diǎn)前插入 void linkBefore(E e, Node<E> succ) {// assert succ != null;// 插入節(jié)點(diǎn)，succ為Index的節(jié)點(diǎn)，可以看到，是插入到index節(jié)點(diǎn)的前一個(gè)節(jié)點(diǎn)final Node<E> pred = succ.prev;final Node<E> newNode = new Node<>(pred, e, succ);succ.prev = newNode;if (pred == null)first = newNode;elsepred.next = newNode;size++;modCount++; }public void add(int index, E element) {checkPositionIndex(index);if (index == size)linkLast(element);elselinkBefore(element, node(index)); } 復(fù)制代碼

同樣，刪除元素只要把刪除節(jié)點(diǎn)的鏈剪掉，再把前后節(jié)點(diǎn)連起來(lái)就搞定了：

E unlink(Node<E> x) {// assert x != null;final E element = x.item;final Node<E> next = x.next;final Node<E> prev = x.prev;if (prev == null) {// 鏈頭first = next;} else {prev.next = next;x.prev = null;}if (next == null) {// 鏈尾last = prev;} else {next.prev = prev;x.next = null;}x.item = null;size--;modCount++;return element; }public E remove(int index) {checkElementIndex(index);return unlink(node(index)); } 復(fù)制代碼

但由于鏈表我們只知道頭和尾，中間的元素要遍歷獲取的，所以導(dǎo)致了訪問(wèn)元素時(shí)，效率就不好了：

Node<E> node(int index) {// 使用了二分法if (index < (size >> 1)) { // 如果索引小于二分之一，從first開(kāi)始遍歷Node<E> x = first;for (int i = 0; i < index; i++)x = x.next;return x;} else { // 如果索引大于二分之一，從last開(kāi)始遍歷Node<E> x = last;for (int i = size - 1; i > index; i--)x = x.prev;return x;} }public E get(int index) {checkElementIndex(index);return node(index).item; } 復(fù)制代碼

所以，LinkedList和ArrayList剛好是互補(bǔ)的，所以具體場(chǎng)景，應(yīng)考慮哪種操作最頻繁，從而選擇不同的List來(lái)使用。

細(xì)節(jié)2：LinkedList可以當(dāng)作隊(duì)列和棧來(lái)使用

不知大家有沒(méi)注意到在圖2.2中，LinkedList非常“特立獨(dú)行地”繼承了Deque接口，而Deque又繼承于Queue接口，這隊(duì)列和棧的方法定義就是在這些接口中定義的，而LinkedList實(shí)現(xiàn)其方法，使自身具備了隊(duì)列的棧的功能。 當(dāng)作隊(duì)列（先進(jìn)先出）使用：

// 進(jìn)隊(duì) public boolean offerFirst(E e) {addFirst(e);return true; }// 出隊(duì) public E pollLast() {final Node<E> l = last;return (l == null) ? null : unlinkLast(l); } 復(fù)制代碼

當(dāng)作棧（后進(jìn)又出）來(lái)使用：

// 進(jìn)棧 public void push(E e) {addFirst(e); }// 出棧，如果為空列表，會(huì)拋出異常 public E pop() {return removeFirst(); } 復(fù)制代碼

SynchronizedList的細(xì)節(jié)

在Collections類(lèi)中提供了很多線程線程的集合類(lèi)，其實(shí)他們實(shí)現(xiàn)很簡(jiǎn)單，只是在集合操作前，加一個(gè)鎖而已。

細(xì)節(jié)1：SynchronizedList繼承于SynchronizedCollection，使用裝飾者模式，為原來(lái)的List加上鎖，從而使List同步安全

先來(lái)看下SynchronizedCollection的定義：

static class SynchronizedCollection<E> implements Collection<E>, Serializable {private static final long serialVersionUID = 3053995032091335093L;final Collection<E> c; // 裝飾的集合final Object mutex; // 鎖SynchronizedCollection(Collection<E> c) {this.c = Objects.requireNonNull(c);mutex = this;}SynchronizedCollection(Collection<E> c, Object mutex) {this.c = Objects.requireNonNull(c);this.mutex = Objects.requireNonNull(mutex);} } 復(fù)制代碼

可以看到，可以指定一個(gè)對(duì)象作為鎖，如果不指定，默認(rèn)就鎖了集合了。 再來(lái)看下我們關(guān)注的SynchronizedList：

static class SynchronizedList<E>extends SynchronizedCollection<E>implements List<E> {final List<E> list;SynchronizedList(List<E> list) {super(list);this.list = list;}SynchronizedList(List<E> list, Object mutex) {super(list, mutex);this.list = list;}...public E get(int index) {synchronized (mutex) {return list.get(index);}}public E set(int index, E element) {synchronized (mutex) {return list.set(index, element);}}public void add(int index, E element) {synchronized (mutex) {list.add(index, element);}}public E remove(int index) {synchronized (mutex) {return list.remove(index);}}... } 復(fù)制代碼

想不到SynchronizedList的實(shí)現(xiàn)是如此簡(jiǎn)單，上面的源碼想必不用我多說(shuō)了。

寫(xiě)在最后

關(guān)于我們經(jīng)常使用的List的細(xì)節(jié)到此就介紹完了，如果上面我有言論有誤或不嚴(yán)謹(jǐn)?shù)?#xff0c;歡迎大家指正；如果有另外一些細(xì)節(jié)我沒(méi)談及到的，也歡迎大神們補(bǔ)充。

最后，我們來(lái)做一次總結(jié)：

• ArrayList和LinkedList適用于不同使用場(chǎng)景，應(yīng)根據(jù)具體場(chǎng)景從優(yōu)選擇
• 根據(jù)ArrayList的擴(kuò)容機(jī)制，我們應(yīng)該開(kāi)始就指定其初始容量，避免資源浪費(fèi)
• LinkedList可以當(dāng)作隊(duì)列和棧使用，當(dāng)然我們也可以進(jìn)一步封裝
• 盡量不使用Vector和Stack，同步場(chǎng)景下，使用SynchronizedList替代

總結(jié)

以上是生活随笔為你收集整理的高手不得不知的Java集合List的细节的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。