ArrayList和LinkedList的區別
參考:
https://blog.csdn.net/qing_gee/article/details/108841587
https://blog.csdn.net/eson_15/article/details/51145788
https://www.cnblogs.com/wwwcnblogscom/p/8036411.html
ArrayList 和 LinkedList有什麼區別
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 有什麼區別的話,你一定會胸有成竹地和他扯上半小時。
ArrayList和LinkedList的區別
前面已經學習完了List部分的原始碼,主要是ArrayList和LinkedList兩部分內容,這一節主要總結下List部分的內容。
List概括
先來回顧一下List在Collection中的的框架圖:
從圖中我們可以看出:
1. List是一個介面,它繼承與Collection介面,代表有序的佇列。
2. AbstractList是一個抽象類,它繼承與AbstractCollection。AbstractList實現了List介面中除了size()、get(int location)之外的方法。
3. AbstractSequentialList是一個抽象類,它繼承與AbstrctList。AbstractSequentialList實現了“連結串列中,根據index索引值操作連結串列的全部方法”。
4. ArrayList、LinkedList、Vector和Stack是List的四個實現類,其中Vector是基於JDK1.0,雖然實現了同步,但是效率低,已經不用了,Stack繼承與Vector,所以不再贅述。
5. LinkedList是個雙向連結串列,它同樣可以被當作棧、佇列或雙端佇列來使用。
ArrayList和LinkedList區別
我們知道,通常情況下,ArrayList和LinkedList的區別有以下幾點:
1. ArrayList是實現了基於動態陣列的資料結構,而LinkedList是基於連結串列的資料結構;
2.對於隨機訪問get和set,ArrayList要優於LinkedList,因為LinkedList要移動指標;
3.對於新增和刪除操作add和remove,一般大家都會說LinkedList要比ArrayList快,因為ArrayList要移動資料。但是實際情況並非這樣,對於新增或刪除,LinkedList和ArrayList並不能明確說明誰快誰慢,下面會詳細分析。
我們結合之前分析的原始碼,來看看為什麼是這樣的:
ArrayList中的隨機訪問、新增和刪除部分原始碼如下:
//獲取index位置的元素值 public E get(int index) { rangeCheck(index); //首先判斷index的範圍是否合法 return elementData(index); } //將index位置的值設為element,並返回原來的值 public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; } //將element新增到ArrayList的指定位置 public void add(int index, E element) { rangeCheckForAdd(index); ensureCapacityInternal(size + 1); // Increments modCount!! //將index以及index之後的資料複製到index+1的位置往後,即從index開始向後挪了一位 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; //然後在index處插入element size++; } //刪除ArrayList指定位置的元素 public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(index); int numMoved = size - index - 1; if (numMoved > 0) //向左挪一位,index位置原來的資料已經被覆蓋了 System.arraycopy(elementData, index+1, elementData, index, numMoved); //多出來的最後一位刪掉 elementData[--size] = null; // clear to let GC do its work return oldValue; }
LinkedList中的隨機訪問、新增和刪除部分原始碼如下:
//獲得第index個節點的值 public E get(int index) { checkElementIndex(index); return node(index).item; } //設定第index元素的值 public E set(int index, E element) { checkElementIndex(index); Node<E> x = node(index); E oldVal = x.item; x.item = element; return oldVal; } //在index個節點之前新增新的節點 public void add(int index, E element) { checkPositionIndex(index); if (index == size) linkLast(element); else linkBefore(element, node(index)); } //刪除第index個節點 public E remove(int index) { checkElementIndex(index); return unlink(node(index)); } //定位index處的節點 Node<E> node(int index) { // assert isElementIndex(index); //index<size/2時,從頭開始找 if (index < (size >> 1)) { Node<E> x = first; for (int i = 0; i < index; i++) x = x.next; return x; } else { //index>=size/2時,從尾開始找 Node<E> x = last; for (int i = size - 1; i > index; i--) x = x.prev; return x; } }
從原始碼可以看出,ArrayList想要get(int index)元素時,直接返回index位置上的元素,而LinkedList需要通過for迴圈進行查詢,雖然LinkedList已經在查詢方法上做了優化,比如index < size / 2,則從左邊開始查詢,反之從右邊開始查詢,但是還是比ArrayList要慢。這點是毋庸置疑的。
ArrayList想要在指定位置插入或刪除元素時,主要耗時的是System.arraycopy動作,會移動index後面所有的元素;LinkedList主耗時的是要先通過for迴圈找到index,然後直接插入或刪除。這就導致了兩者並非一定誰快誰慢,下面通過一個測試程式來測試一下兩者插入的速度:
import java.util.ArrayList; import java.util.Collections; import java.util.LinkedList; import java.util.List; /* * @description 測試ArrayList和LinkedList插入的效率 * @eson_15 */ public class ArrayOrLinked { static List<Integer> array=new ArrayList<Integer>(); static List<Integer> linked=new LinkedList<Integer>(); public static void main(String[] args) { //首先分別給兩者插入10000條資料 for(int i=0;i<10000;i++){ array.add(i); linked.add(i); } //獲得兩者隨機訪問的時間 System.out.println("array time:"+getTime(array)); System.out.println("linked time:"+getTime(linked)); //獲得兩者插入資料的時間 System.out.println("array insert time:"+insertTime(array)); System.out.println("linked insert time:"+insertTime(linked)); } public static long getTime(List<Integer> list){ long time=System.currentTimeMillis(); for(int i = 0; i < 10000; i++){ int index = Collections.binarySearch(list, list.get(i)); if(index != i){ System.out.println("ERROR!"); } } return System.currentTimeMillis()-time; } //插入資料 public static long insertTime(List<Integer> list){ /* * 插入的資料量和插入的位置是決定兩者效能的主要方面, * 我們可以通過修改這兩個資料,來測試兩者的效能 */ long num = 10000; //表示要插入的資料量 int index = 1000; //表示從哪個位置插入 long time=System.currentTimeMillis(); for(int i = 1; i < num; i++){ list.add(index, i); } return System.currentTimeMillis()-time; } }
主要有兩個因素決定他們的效率,插入的資料量和插入的位置。我們可以在程式裡改變這兩個因素來測試它們的效率。
當資料量較小時,測試程式中,大約小於30的時候,兩者效率差不多,沒有顯著區別;當資料量較大時,大約在容量的1/10處開始,LinkedList的效率就開始沒有ArrayList效率高了,特別到一半以及後半的位置插入時,LinkedList效率明顯要低於ArrayList,而且資料量越大,越明顯。比如我測試了一種情況,在index=1000的位置(容量的1/10)插入10000條資料和在index=5000的位置以及在index=9000的位置插入10000條資料的執行時間如下:
在index=1000出插入結果: array time:4 linked time:240 array insert time:20 linked insert time:18 在index=5000處插入結果: array time:4 linked time:229 array insert time:13 linked insert time:90 在index=9000處插入結果: array time:4 linked time:237 array insert time:7 linked insert time:92
從執行結果看,LinkedList的效率是越來越差。
所以當插入的資料量很小時,兩者區別不太大,當插入的資料量大時,大約在容量的1/10之前,LinkedList會優於ArrayList,在其後就劣與ArrayList,且越靠近後面越差。所以個人覺得,一般首選用ArrayList,由於LinkedList可以實現棧、佇列以及雙端佇列等資料結構,所以當特定需要時候,使用LinkedList,當然咯,資料量小的時候,兩者差不多,視具體情況去選擇使用;當資料量大的時候,如果只需要在靠前的部分插入或刪除資料,那也可以選用LinkedList,反之選擇ArrayList反而效率更高。
ArrayList和LinkedList的區別
ArrayList和Vector使用了陣列的實現,可以認為ArrayList或者Vector封裝了對內部陣列的操作,比如向陣列中新增,刪除,插入新的元素或者資料的擴充套件和重定向。
LinkedList使用了迴圈雙向連結串列資料結構。與基於陣列ArrayList相比,這是兩種截然不同的實現技術,這也決定了它們將適用於完全不同的工作場景。
LinkedList連結串列由一系列表項連線而成。一個表項總是包含3個部分:元素內容,前驅表和後驅表,如圖所示:
在下圖展示了一個包含3個元素的LinkedList的各個表項間的連線關係。在JDK的實現中,無論LikedList是否為空,連結串列內部都有一個header表項,它既表示連結串列的開始,也表示連結串列的結尾。表項header的後驅表項便是連結串列中第一個元素,表項header的前驅表項便是連結串列中最後一個元素。
下面以增加和刪除元素為例比較ArrayList和LinkedList的不同之處:
(1)增加元素到列表尾端:
在ArrayList中增加元素到佇列尾端的程式碼如下:
public boolean add(E e){ ensureCapacity(size+1);//確保內部陣列有足夠的空間 elementData[size++]=e;//將元素加入到陣列的末尾,完成新增 return true; }
ArrayList中add()方法的效能決定於ensureCapacity()方法。ensureCapacity()的實現如下:
public vod ensureCapacity(int minCapacity){ modCount++; int oldCapacity=elementData.length; if(minCapacity>oldCapacity){ //如果陣列容量不足,進行擴容 Object[] oldData=elementData; int newCapacity=(oldCapacity*3)/2+1; //擴容到原始容量的1.5倍 if(newCapacitty<minCapacity) //如果新容量小於最小需要的容量,則使用最小 //需要的容量大小 newCapacity=minCapacity ; //進行擴容的陣列複製 elementData=Arrays.copyof(elementData,newCapacity); } }
可以看到,只要ArrayList的當前容量足夠大,add()操作的效率非常高的。只有當ArrayList對容量的需求超出當前陣列大小時,才需要進行擴容。擴容的過程中,會進行大量的陣列複製操作。而陣列複製時,最終將呼叫System.arraycopy()方法,因此add()操作的效率還是相當高的。
LinkedList 的add()操作實現如下,它也將任意元素增加到佇列的尾端:
public boolean add(E e){ addBefore(e,header);//將元素增加到header的前面 return true; }
其中addBefore()的方法實現如下:
private Entry<E> addBefore(E e,Entry<E> entry){ Entry<E> newEntry = new Entry<E>(e,entry,entry.previous); newEntry.provious.next=newEntry; newEntry.next.previous=newEntry; size++; modCount++; return newEntry; }
可見,LinkeList由於使用了連結串列的結構,因此不需要維護容量的大小。從這點上說,它比ArrayList有一定的效能優勢,然而,每次的元素增加都需要新建一個Entry物件,並進行更多的賦值操作。在頻繁的系統呼叫中,對效能會產生一定的影響。
(2)增加元素到列表任意位置
除了提供元素到List的尾端,List介面還提供了在任意位置插入元素的方法:void add(int index,E element);
由於實現的不同,ArrayList和LinkedList在這個方法上存在一定的效能差異,由於ArrayList是基於陣列實現的,而陣列是一塊連續的記憶體空間,如果在陣列的任意位置插入元素,必然導致在該位置後的所有元素需要重新排列,因此,其效率相對會比較低。
以下程式碼是ArrayList中的實現:
public void add(int index,E element){ if(index>size||index<0) throw new IndexOutOfBoundsException( "Index:"+index+",size: "+size); ensureCapacity(size+1); System.arraycopy(elementData,index,elementData,index+1,size-index); elementData[index] = element; size++; }
可以看到每次插入操作,都會進行一次陣列複製。而這個操作在增加元素到List尾端的時候是不存在的,大量的陣列重組操作會導致系統性能低下。並且插入元素在List中的位置越是靠前,陣列重組的開銷也越大。
而LinkedList此時顯示了優勢:
public void add(int index,E element){ addBefore(element,(index==size?header:entry(index))); }
可見,對LinkedList來說,在List的尾端插入資料與在任意位置插入資料是一樣的,不會因為插入的位置靠前而導致插入的方法效能降低。
(3)刪除任意位置元素
對於元素的刪除,List介面提供了在任意位置刪除元素的方法:
public E remove(int index);
對ArrayList來說,remove()方法和add()方法是雷同的。在任意位置移除元素後,都要進行陣列的重組。ArrayList的實現如下:
public E remove(int index){ RangeCheck(index); modCount++; E oldValue=(E) elementData[index]; int numMoved=size-index-1; if(numMoved>0) System.arraycopy(elementData,index+1,elementData,index,numMoved); elementData[--size]=null; return oldValue; }
可以看到,在ArrayList的每一次有效的元素刪除操作後,都要進行陣列的重組。並且刪除的位置越靠前,陣列重組時的開銷越大。
public E remove(int index){ return remove(entry(index)); } private Entry<E> entry(int index){ if(index<0 || index>=size) throw new IndexOutBoundsException("Index:"+index+",size:"+size); Entry<E> e= header; if(index<(size>>1)){//要刪除的元素位於前半段 for(int i=0;i<=index;i++) e=e.next; }else{ for(int i=size;i>index;i--) e=e.previous; } return e; }
在LinkedList的實現中,首先要通過迴圈找到要刪除的元素。如果要刪除的位置處於List的前半段,則從前往後找;若其位置處於後半段,則從後往前找。因此無論要刪除較為靠前或者靠後的元素都是非常高效的;但要移除List中間的元素卻幾乎要遍歷完半個List,在List擁有大量元素的情況下,效率很低。
(4)容量引數
容量引數是ArrayList和Vector等基於陣列的List的特有效能引數。它表示初始化的陣列大小。當ArrayList所儲存的元素數量超過其已有大小時。它便會進行擴容,陣列的擴容會導致整個陣列進行一次記憶體複製。因此合理的陣列大小有助於減少陣列擴容的次數,從而提高系統性能。
public ArrayList(){ this(10); } public ArrayList (int initialCapacity){ super(); if(initialCapacity<0) throw new IllegalArgumentException("Illegal Capacity:"+initialCapacity) this.elementData=new Object[initialCapacity]; }
ArrayList提供了一個可以制定初始陣列大小的建構函式:
public ArrayList(int initialCapacity)
現以構造一個擁有100萬元素的List為例,當使用預設初始化大小時,其消耗的相對時間為125ms左右,當直接制定陣列大小為100萬時,構造相同的ArrayList僅相對耗時16ms。
(5)遍歷列表
遍歷列表操作是最常用的列表操作之一,在JDK1.5之後,至少有3中常用的列表遍歷方式:forEach操作,迭代器和for迴圈。
String tmp; long start=System.currentTimeMills(); //ForEach for(String s:list){ tmp=s; } System.out.println("foreach spend:"+(System.currentTimeMills()-start)); start = System.currentTimeMills(); for(Iterator<String> it=list.iterator();it.hasNext();){ tmp=it.next(); } System.out.println("Iterator spend;"+(System.currentTimeMills()-start)); start=System.currentTimeMills(); int size=;list.size(); for(int i=0;i<size;i++){ tmp=list.get(i); } System.out.println("for spend;"+(System.currentTimeMills()-start));
構造一個擁有100萬資料的ArrayList和等價的LinkedList,使用以上程式碼進行測試,測試結果的相對耗時如下表所示:
可以看到,最簡便的ForEach迴圈並沒有很好的效能表現,綜合性能不如普通的迭代器,而是用for迴圈通過隨機訪問遍歷列表時,ArrayList表項很好,但是LinkedList的表現卻無法讓人接受,甚至沒有辦法等待程式的結束。這是因為對LinkedList進行隨機訪問時,總會進行一次列表的遍歷操作。效能非常差,應避免使用。
參考連結:https://www.cnblogs.com/sierrajuan/p/3639353.html