ArrayList 和 LinkedList 有什么區別，是面試官非常喜歡問的一個問題，可能大部分小伙伴和我一樣，能回答出“ArrayList 是基于陣列實作的，LinkedList 是基于雙向鏈表實作的，”
關于這一點，我之前的文章里也提到過了，但說實話，這樣蒼白的回答并不能令面試官感到滿意，他還想知道的更多，
那假如小伙伴們繼續做出下面這樣的回答：
“ArrayList 在新增和洗掉元素時，因為涉及到陣列復制，所以效率比 LinkedList 低，而在遍歷的時候，ArrayList 的效率要高于 LinkedList，”
面試官會感到滿意嗎？我只能說，如果面試官比較仁慈的話，他可能會讓我們回答下一個問題；否則的話，他會讓我們回家等通知，這一等，可能意味著杳無音訊了，
為什么會這樣呢？為什么為什么？回答的不對嗎？
暴躁的小伙伴請喝口奶茶冷靜一下，冷靜下來后，請隨我來，讓我們一起肩并肩、手拉手地深入地研究一下 ArrayList 和 LinkedList 的資料結構、實作原理以及原始碼，可能神秘的面紗就揭開了，
01、ArrayList 是如何實作的？
ArrayList 實作了 List 介面，繼承了 AbstractList 抽象類，底層是基于陣列實作的，并且實作了動態擴容，
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final int DEFAULT_CAPACITY = 10;
transient Object[] elementData;
private int size;
}
ArrayList 還實作了 RandomAccess 介面，這是一個標記介面：
public interface RandomAccess {
}
內部是空的，標記“實作了這個介面的類支持快速（通常是固定時間）隨機訪問”，快速隨機訪問是什么意思呢？就是說不需要遍歷，就可以通過下標（索引）直接訪問到記憶體地址，
public E get(int index) {
Objects.checkIndex(index, size);
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
ArrayList 還實作了 Cloneable 介面，這表明 ArrayList 是支持拷貝的，ArrayList 內部的確也重寫了 Object 類的 clone() 方法，
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
ArrayList 還實作了 Serializable 介面，同樣是一個標記介面：
public interface Serializable {
}
內部也是空的，標記“實作了這個介面的類支持序列化”，序列化是什么意思呢？Java 的序列化是指，將物件轉換成以位元組序列的形式來表示，這些位元組序中包含了物件的欄位和方法，序列化后的物件可以被寫到資料庫、寫到檔案，也可用于網路傳輸，
眼睛雪亮的小伙伴可能會注意到，ArrayList 中的關鍵欄位 elementData 使用了 transient 關鍵字修飾，這個關鍵字的作用是，讓它修飾的欄位不被序列化，
這不前后矛盾嗎？一個類既然實作了 Serilizable 介面，肯定是想要被序列化的，對吧？那為什么保存關鍵資料的 elementData 又不想被序列化呢?
這還得從 “ArrayList 是基于陣列實作的”開始說起，大家都知道，陣列是定長的，就是說，陣列一旦宣告了，長度（容量）就是固定的，不能像某些東西一樣伸縮自如，這就很麻煩，陣列一旦裝滿了，就不能添加新的元素進來了，
ArrayList 不想像陣列這樣活著，它想能屈能伸，所以它實作了動態擴容，一旦在添加元素的時候，發現容量用滿了 s == elementData.length，就按照原來陣列的 1.5 倍（oldCapacity >> 1）進行擴容，擴容之后，再將原有的陣列復制到新分配的記憶體地址上 Arrays.copyOf(elementData, newCapacity)，
private void add(E e, Object[] elementData, int s) {
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
private Object[] grow() {
return grow(size + 1);
}
private Object[] grow(int minCapacity) {
int oldCapacity = elementData.length;
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
int newCapacity = ArraysSupport.newLength(oldCapacity,
minCapacity - oldCapacity, /* minimum growth */
oldCapacity >> 1 /* preferred growth */);
return elementData = Arrays.copyOf(elementData, newCapacity);
} else {
return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
}
}
動態擴容意味著什么？大家伙想一下，嗯，還是我來告訴大家答案吧，有點迫不及待，
意味著陣列的實際大小可能永遠無法被填滿的，總有多余出來空置的記憶體空間，
比如說，默認的陣列大小是 10，當添加第 11 個元素的時候，陣列的長度擴容了 1.5 倍，也就是 15，意味著還有 4 個記憶體空間是閑置的，對吧？
序列化的時候，如果把整個陣列都序列化的話，是不是就多序列化了 4 個記憶體空間，當存盤的元素數量非常非常多的時候，閑置的空間就非常非常大，序列化耗費的時間就會非常非常多，
于是，ArrayList 做了一個愉快而又聰明的決定，內部提供了兩個私有方法 writeObject 和 readObject 來完成序列化和反序列化，
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 size as capacity for behavioral compatibility with clone()
s.writeInt(size);
// 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();
}
}
從 writeObject 方法的原始碼中可以看得出，它使用了 ArrayList 的實際大小 size 而不是陣列的長度（elementData.length）來作為元素的上限進行序列化，
此處應該有掌聲啊！不是為我，為 Java 原始碼的作者們，他們真的是太厲害了，可以用兩個詞來形容他們——殫精竭慮、精益求精，
02、LinkedList 是如何實作的？
LinkedList 是一個繼承自 AbstractSequentialList 的雙向鏈表，因此它也可以被當作堆疊、佇列或雙端佇列進行操作，
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
}
LinkedList 內部定義了一個 Node 節點，它包含 3 個部分：元素內容 item，前參考 prev 和后參考 next，代碼如下所示：
private static class Node<E> {
E item;
LinkedList.Node<E> next;
LinkedList.Node<E> prev;
Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
LinkedList 還實作了 Cloneable 介面，這表明 LinkedList 是支持拷貝的，
LinkedList 還實作了 Serializable 介面，這表明 LinkedList 是支持序列化的，眼睛雪亮的小伙伴可能又注意到了，LinkedList 中的關鍵欄位 size、first、last 都使用了 transient 關鍵字修飾，這不又矛盾了嗎？到底是想序列化還是不想序列化？
答案是 LinkedList 想按照自己的方式序列化，來看它自己實作的 writeObject() 方法：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (LinkedList.Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}
發現沒？LinkedList 在序列化的時候只保留了元素的內容 item，并沒有保留元素的前后參考，這樣就節省了不少記憶體空間，對吧？
那有些小伙伴可能就疑惑了，只保留元素內容，不保留前后參考，那反序列化的時候怎么辦？
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}
void linkLast(E e) {
final LinkedList.Node<E> l = last;
final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
注意 for 回圈中的 linkLast() 方法，它可以把鏈表重新鏈接起來，這樣就恢復了鏈表序列化之前的順序，很妙，對吧？
和 ArrayList 相比，LinkedList 沒有實作 RandomAccess 介面，這是因為 LinkedList 存盤資料的記憶體地址是不連續的，所以不支持隨機訪問，
03、ArrayList 和 LinkedList 新增元素時究竟誰快？
前面我們已經從多個維度了解了 ArrayList 和 LinkedList 的實作原理和各自的特點，那接下來，我們就來聊聊 ArrayList 和 LinkedList 在新增元素時究竟誰快？
1）ArrayList
ArrayList 新增元素有兩種情況，一種是直接將元素添加到陣列末尾，一種是將元素插入到指定位置，
添加到陣列末尾的原始碼：
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
private void add(E e, Object[] elementData, int s) {
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
很簡單，先判斷是否需要擴容，然后直接通過索引將元素添加到末尾，
插入到指定位置的原始碼：
public void add(int index, E element) {
rangeCheckForAdd(index);
modCount++;
final int s;
Object[] elementData;
if ((s = size) == (elementData = this.elementData).length)
elementData = grow();
System.arraycopy(elementData, index,
elementData, index + 1,
s - index);
elementData[index] = element;
size = s + 1;
}
先檢查插入的位置是否在合理的范圍之內，然后判斷是否需要擴容，再把該位置以后的元素復制到新添加元素的位置之后，最后通過索引將元素添加到指定的位置，這種情況是非常傷的，性能會比較差，
2）LinkedList
LinkedList 新增元素也有兩種情況，一種是直接將元素添加到隊尾，一種是將元素插入到指定位置，
添加到隊尾的原始碼：
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final LinkedList.Node<E> l = last;
final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
先將隊尾的節點 last 存放到臨時變數 l 中（不是說不建議使用 I 作為變數名嗎？Java 的作者們明知故犯啊），然后生成新的 Node 節點，并賦給 last，如果 l 為 null，說明是第一次添加，所以 first 為新的節點；否則將新的節點賦給之前 last 的 next，
插入到指定位置的原始碼：
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
LinkedList.Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
LinkedList.Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
LinkedList.Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
void linkBefore(E e, LinkedList.Node<E> succ) {
// assert succ != null;
final LinkedList.Node<E> pred = succ.prev;
final LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
先檢查插入的位置是否在合理的范圍之內，然后判斷插入的位置是否是隊尾，如果是，添加到隊尾；否則執行 linkBefore() 方法，
在執行 linkBefore() 方法之前，會呼叫 node() 方法查找指定位置上的元素，這一步是需要遍歷 LinkedList 的，如果插入的位置靠前前半段，就從隊頭開始往后找；否則從隊尾往前找，也就是說，如果插入的位置越靠近 LinkedList 的中間位置，遍歷所花費的時間就越多，
找到指定位置上的元素（succ）之后，就開始執行 linkBefore() 方法了，先將 succ 的前一個節點（prev）存放到臨時變數 pred 中，然后生成新的 Node 節點（newNode），并將 succ 的前一個節點變更為 newNode，如果 pred 為 null，說明插入的是隊頭，所以 first 為新節點；否則將 pred 的后一個節點變更為 newNode，
經過原始碼分析以后，小伙伴們是不是在想：“好像 ArrayList 在新增元素的時候效率并不一定比 LinkedList 低啊！”
當兩者的起始長度是一樣的情況下：
- 如果是從集合的頭部新增元素，ArrayList 花費的時間應該比 LinkedList 多，因為需要對頭部以后的元素進行復制，
public class ArrayListTest {
public static void addFromHeaderTest(int num) {
ArrayList<String> list = new ArrayList<String>(num);
int i = 0;
long timeStart = System.currentTimeMillis();
while (i < num) {
list.add(0, i + "沉默王二");
i++;
}
long timeEnd = System.currentTimeMillis();
System.out.println("ArrayList從集合頭部位置新增元素花費的時間" + (timeEnd - timeStart));
}
}
/**
* @author 微信搜「沉默王二」，回復關鍵字 PDF
*/
public class LinkedListTest {
public static void addFromHeaderTest(int num) {
LinkedList<String> list = new LinkedList<String>();
int i = 0;
long timeStart = System.currentTimeMillis();
while (i < num) {
list.addFirst(i + "沉默王二");
i++;
}
long timeEnd = System.currentTimeMillis();
System.out.println("LinkedList從集合頭部位置新增元素花費的時間" + (timeEnd - timeStart));
}
}
num 為 10000，代碼實測后的時間如下所示：
ArrayList從集合頭部位置新增元素花費的時間595
LinkedList從集合頭部位置新增元素花費的時間15
ArrayList 花費的時間比 LinkedList 要多很多，
- 如果是從集合的中間位置新增元素，ArrayList 花費的時間搞不好要比 LinkedList 少，因為 LinkedList 需要遍歷，
public class ArrayListTest {
public static void addFromMidTest(int num) {
ArrayList<String> list = new ArrayList<String>(num);
int i = 0;
long timeStart = System.currentTimeMillis();
while (i < num) {
int temp = list.size();
list.add(temp / 2 + "沉默王二");
i++;
}
long timeEnd = System.currentTimeMillis();
System.out.println("ArrayList從集合中間位置新增元素花費的時間" + (timeEnd - timeStart));
}
}
public class LinkedListTest {
public static void addFromMidTest(int num) {
LinkedList<String> list = new LinkedList<String>();
int i = 0;
long timeStart = System.currentTimeMillis();
while (i < num) {
int temp = list.size();
list.add(temp / 2, i + "沉默王二");
i++;
}
long timeEnd = System.currentTimeMillis();
System.out.println("LinkedList從集合中間位置新增元素花費的時間" + (timeEnd - timeStart));
}
}
num 為 10000，代碼實測后的時間如下所示：
ArrayList從集合中間位置新增元素花費的時間1
LinkedList從集合中間位置新增元素花費的時間101
ArrayList 花費的時間比 LinkedList 要少很多很多，
- 如果是從集合的尾部新增元素，ArrayList 花費的時間應該比 LinkedList 少，因為陣列是一段連續的記憶體空間，也不需要復制陣列；而鏈表需要創建新的物件，前后參考也要重新排列，
public class ArrayListTest {
public static void addFromTailTest(int num) {
ArrayList<String> list = new ArrayList<String>(num);
int i = 0;
long timeStart = System.currentTimeMillis();
while (i < num) {
list.add(i + "沉默王二");
i++;
}
long timeEnd = System.currentTimeMillis();
System.out.println("ArrayList從集合尾部位置新增元素花費的時間" + (timeEnd - timeStart));
}
}
public class LinkedListTest {
public static void addFromTailTest(int num) {
LinkedList<String> list = new LinkedList<String>();
int i = 0;
long timeStart = System.currentTimeMillis();
while (i < num) {
list.add(i + "沉默王二");
i++;
}
long timeEnd = System.currentTimeMillis();
System.out.println("LinkedList從集合尾部位置新增元素花費的時間" + (timeEnd - timeStart));
}
}
num 為 10000，代碼實測后的時間如下所示：
ArrayList從集合尾部位置新增元素花費的時間69
LinkedList從集合尾部位置新增元素花費的時間193
ArrayList 花費的時間比 LinkedList 要少一些，
這樣的結論和預期的是不是不太相符？ArrayList 在添加元素的時候如果不涉及到擴容，性能在兩種情況下（中間位置新增元素、尾部新增元素）比 LinkedList 好很多，只有頭部新增元素的時候比 LinkedList 差，因為陣列復制的原因，
當然了，如果涉及到陣列擴容的話，ArrayList 的性能就沒那么可觀了，因為擴容的時候也要復制陣列，
04、ArrayList 和 LinkedList 洗掉元素時究竟誰快？
1）ArrayList
ArrayList 洗掉元素的時候，有兩種方式，一種是直接洗掉元素（remove(Object)），需要直先遍歷陣列，找到元素對應的索引；一種是按照索引洗掉元素（remove(int)），
public boolean remove(Object o) {
final Object[] es = elementData;
final int size = this.size;
int i = 0;
found: {
if (o == null) {
for (; i < size; i++)
if (es[i] == null)
break found;
} else {
for (; i < size; i++)
if (o.equals(es[i]))
break found;
}
return false;
}
fastRemove(es, i);
return true;
}
public E remove(int index) {
Objects.checkIndex(index, size);
final Object[] es = elementData;
@SuppressWarnings("unchecked") E oldValue = (E) es[index];
fastRemove(es, index);
return oldValue;
}
但從本質上講，都是一樣的，因為它們最后呼叫的都是 fastRemove(Object, int) 方法，
private void fastRemove(Object[] es, int i) {
modCount++;
final int newSize;
if ((newSize = size - 1) > i)
System.arraycopy(es, i + 1, es, i, newSize - i);
es[size = newSize] = null;
}
從原始碼可以看得出，只要洗掉的不是最后一個元素，都需要陣列重組，洗掉的元素位置越靠前，代價就越大，
2）LinkedList
LinkedList 洗掉元素的時候，有四種常用的方式：
remove(int)，洗掉指定位置上的元素
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
先檢查索引，再呼叫 node(int) 方法（ 前后半段遍歷，和新增元素操作一樣）找到節點 Node，然后呼叫 unlink(Node) 解除節點的前后參考，同時更新前節點的后參考和后節點的前參考：
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;
}
remove(Object)，直接洗掉元素
public boolean remove(Object o) {
if (o == null) {
for (LinkedList.Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (LinkedList.Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
也是先前后半段遍歷，找到要洗掉的元素后呼叫 unlink(Node)，
removeFirst()，洗掉第一個節點
public E removeFirst() {
final LinkedList.Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
private E unlinkFirst(LinkedList.Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final LinkedList.Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
洗掉第一個節點就不需要遍歷了，只需要把第二個節點更新為第一個節點即可，
removeLast()，洗掉最后一個節點
洗掉最后一個節點和洗掉第一個節點類似，只需要把倒數第二個節點更新為最后一個節點即可，
可以看得出，LinkedList 在洗掉比較靠前和比較靠后的元素時，非常高效，但如果洗掉的是中間位置的元素，效率就比較低了，
這里就不再做代碼測驗了，感興趣的小伙伴可以自己試試，結果和新增元素保持一致：
-
從集合頭部洗掉元素時，ArrayList 花費的時間比 LinkedList 多很多；
-
從集合中間位置洗掉元素時，ArrayList 花費的時間比 LinkedList 少很多；
-
從集合尾部洗掉元素時，ArrayList 花費的時間比 LinkedList 少一點，
我本地的統計結果如下所示，小伙伴們可以作為參考：
ArrayList從集合頭部位置洗掉元素花費的時間380
LinkedList從集合頭部位置洗掉元素花費的時間4
ArrayList從集合中間位置洗掉元素花費的時間381
LinkedList從集合中間位置洗掉元素花費的時間5922
ArrayList從集合尾部位置洗掉元素花費的時間8
LinkedList從集合尾部位置洗掉元素花費的時間12
05、ArrayList 和 LinkedList 遍歷元素時究竟誰快？
1）ArrayList
遍歷 ArrayList 找到某個元素的話，通常有兩種形式：
get(int)，根據索引找元素
public E get(int index) {
Objects.checkIndex(index, size);
return elementData(index);
}
由于 ArrayList 是由陣列實作的，所以根據索引找元素非常的快，一步到位，
indexOf(Object)，根據元素找索引
public int indexOf(Object o) {
return indexOfRange(o, 0, size);
}
int indexOfRange(Object o, int start, int end) {
Object[] es = elementData;
if (o == null) {
for (int i = start; i < end; i++) {
if (es[i] == null) {
return i;
}
}
} else {
for (int i = start; i < end; i++) {
if (o.equals(es[i])) {
return i;
}
}
}
return -1;
}
根據元素找索引的話，就需要遍歷整個陣列了，從頭到尾依次找，
2）LinkedList
遍歷 LinkedList 找到某個元素的話，通常也有兩種形式：
get(int)，找指定位置上的元素
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
既然需要呼叫 node(int) 方法，就意味著需要前后半段遍歷了，
indexOf(Object)，找元素所在的位置
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (LinkedList.Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (LinkedList.Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
需要遍歷整個鏈表，和 ArrayList 的 indexOf() 類似，
那在我們對集合遍歷的時候，通常有兩種做法，一種是使用 for 回圈，一種是使用迭代器（Iterator），
如果使用的是 for 回圈，可想而知 LinkedList 在 get 的時候性能會非常差，因為每一次外層的 for 回圈，都要執行一次 node(int) 方法進行前后半段的遍歷，
LinkedList.Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
LinkedList.Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
LinkedList.Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
那如果使用的是迭代器呢？
LinkedList<String> list = new LinkedList<String>();
for (Iterator<String> it = list.iterator(); it.hasNext();) {
it.next();
}
迭代器只會呼叫一次 node(int) 方法，在執行 list.iterator() 的時候：先呼叫 AbstractSequentialList 類的 iterator() 方法，再呼叫 AbstractList 類的 listIterator() 方法，再呼叫 LinkedList 類的 listIterator(int) 方法，如下圖所示，
最后回傳的是 LinkedList 類的內部私有類 ListItr 物件：
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new LinkedList.ListItr(index);
}
private class ListItr implements ListIterator<E> {
private LinkedList.Node<E> lastReturned;
private LinkedList.Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
}
執行 ListItr 的構造方法時呼叫了一次 node(int) 方法，回傳第一個節點，在此之后，迭代器就執行 hasNext() 判斷有沒有下一個，執行 next() 方法下一個節點，
由此，可以得出這樣的結論：遍歷 LinkedList 的時候，千萬不要使用 for 回圈，要使用迭代器，
也就是說，for 回圈遍歷的時候，ArrayList 花費的時間遠小于 LinkedList；迭代器遍歷的時候，兩者性能差不多，
06、總結
花了兩天時間，終于肝完了！相信看完這篇文章后，再有面試官問你 ArrayList 和 LinkedList 有什么區別的話，你一定會胸有成竹地和他扯上半小時，
另外，我把自己看過的學習視頻按照順序分了類，共 500G，目錄如下，還有 2020 年最新面試題，現在免費送給大家，
鏈接:https://pan.baidu.com/s/1FOxmYlnU8qBGBNV2-VUk4Q 密碼:hexs
我是沉默王二，一枚沉默但有趣的程式員，感謝各位同學的：點贊、收藏和評論，我們下篇見！
CSDN認證博客專家
博客之星
博客專家
Java 大牛
轉載請註明出處，本文鏈接：https://www.uj5u.com/qianduan/140136.html
標籤：其他