讀懂LinkedList這一篇就夠了
本文全部代碼來自JDK1.8java
想象幼兒園小朋友放學回家，老師要求小朋友們排成一字隊，先後小朋友都手牽着手，舉個栗子小明是排在前面第一位同窗，他的右手牽着後面小紅的左手，小紅的右手牽着後面小強的左手，以此類推，直到全部你們都手牽着手，開開心心的放學回家~ 因爲小馮剛剛拉肚子沒有在隊伍中，他如今想加入到隊伍中並且想站在小紅的後面，他須要先讓小紅和小強的手鬆開，而後左手牽住小紅的右手，右手牽住小強的左手，這樣就加入到隊伍中了。 其實這種結構就像LinkedListnode
簡介
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable 複製代碼
LinkedList繼承AbstractSequentialList類，實現了List, Deque（雙端隊列，具備隊列和棧性質的一種數據結構）, Cloneable, java.io.Serializable接口。安全
remove()方法，實際上是刪除鏈表第一個元素，後面詳細介紹
源碼分析
成員屬性及構造函數
transient int size = 0;
/** * Pointer to first node. * Invariant: (first == null && last == null) || * (first.prev == null && first.item != null) */
transient Node<E> first;
/** * Pointer to last node. * Invariant: (first == null && last == null) || * (last.next == null && last.item != null) */
transient Node<E> last;
/** * Constructs an empty list. */
public LinkedList() {
}
/** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
複製代碼
size爲此列表中元素個數,初始化爲0，first始終指向列表中第一個元素，last始終指向列表最後一個元素，這三個成員都具備transient屬性，重寫了序列化函數，記錄這個鏈表屬性的狀態bash
LinkedList()此無參構造函數中沒有都沒有作，對比在ArrayList中的無參構造函數建立一個爲默認大小爲10的空列表。數據結構
LinkedList(Collection<? extends E> c)構建一個包含指定集合的全部元素的列表，元素順序按照集合迭代器返回的順序函數
存儲單元
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
複製代碼
經常使用函數及底層輔助函數
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node<E> node(int index) {
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
-----------輔助函數------------
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
複製代碼
這個很簡單，經過index >= 0 && index < size判斷是否在範圍內，若不在拋出下標越界異常；不然值得注意，node(int index)經過與size/2大小判斷索引是在鏈表前半段仍是後半段，相比於每次都從first向last遍歷，這種方式可減小遍歷次數。源碼分析
public boolean add(E e) {
linkLast(e);
return true;
}
public boolean offer(E e) {
return add(e);
}
public void addLast(E e) {
linkLast(e);
}
public boolean offerLast(E e) {
addLast(e);
return true;
}
----------------------------------
public void push(E e) {
addFirst(e);
}
public void addFirst(E e) {
linkFirst(e);
}
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
複製代碼
因爲實現了Deque接口，方法較多，但其實調用的底層代碼是同樣的，通常仍是使用add較多。值得注意的是Deque中addLast(E e)只是在鏈表最後插入元素可是沒有返回值的，同理addFirst(E e)也是沒有返回值的。ui
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
複製代碼
值得注意isPositionIndex()和以前isElementIndex()有小小區別，在此index <= size說明能夠在最後插入元素，可是在get()中index爲size是已經越界。this
-----------輔助函數------------
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;
else
l.next = newNode;
size++;
modCount++;
}
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
複製代碼
前一個方法是在鏈表後面添加節點，後一個方法是在鏈表前面添加節點，以講linkLast（E e）爲例spa
一、鏈表中最後一個元素last用l表示
二、構造new Node<>(l, e, null)新節點，前向指針指向最後一個元素，後向指針指向null
三、last = newNode表示將新的節點插入到最後面，判斷此鏈表是否爲空，如果則鏈表的first指向新加入的節點；若不是就將以前爲last的節點後向指針指向新插入的節點。
四、鏈表大小增長1，改動次數增長1
public E remove() {
return removeFirst();
}
public E pop() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
複製代碼
於實現了Deque接口，方法較多，但其實調用的底層代碼是同樣的，通常仍是使用remove較多。第一個值得注意remove()和pop()對空鏈表狀況會拋出NoSuchElementException，一樣狀況在poll()中會返回null。第二個值得注意的是remove()刪除的是第一個元素，而不是最後的元素，若想刪除最後的元素，應該使用removeLast()。
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final 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;
}
複製代碼
unlinkFirst(Node<E> f)方法是在鏈表刪除first元素，unlinkLast(Node f)方法是在鏈表刪除last元素，原理相似，詳細介紹unlinkFirst(Node<E> f)爲例
一、先記錄如今的first元素，和如今first的next元素記做next（將被做爲first）
二、由於first.prev就是null，只用對f.next置null就至關於開頭例子中鬆開與後面小朋友的手同樣，f.item 也要置null，更好的垃圾回收
三、刪除以後，next成爲鏈表的first元素//思考是否是能夠結束了？
四、判斷next是否爲空，如果，last值爲null（ first = next，first也爲null）;若不是則next.prev置null，成爲真正意義上的first
五、鏈表大小減小1，改動次數增長1
六、返回刪除的元素item
--------------------------------
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
-----------輔助函數------------
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 o)刪除鏈表中的元素，從first向last遍歷，直到找到第一個出現的對應元素，而後刪除，返回true；若找不到則返回false。例子中假設o叫作小歐，讓小歐前面小朋友先經過小歐牽住小歐後面小朋友的手（同理對後面小朋友來講也就牽住了前面小朋友的手），而後小歐就從隊伍中分離了，也就刪除了元素o。
public void clear() {
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
複製代碼
清除全部的元素，item、prev、next及first、last所有置爲null，size置爲0，改動次數增長1。清除節點之間的全部連接是「沒必要要的」，可是可幫助一代GC確保釋放內存。
LinkedList遍歷比較
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private 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;
}
......
}
複製代碼
public ListIterator<E> listIterator() {
return listIterator(0);
}
複製代碼
迭代器和普通循環方法對比起來少了一個list.get(i)，LinkedList中調用了一次get(i)，就從咱們知道這個時間複雜度應該是O（n），再嵌套一個for循環是O（n^2）；迭代器其實每次沒從first或last從新開始遍歷，記錄當前的位置，iterator中由於next的存在因此循環下來時間複雜度是O（n），所以差距就在這裏。
上篇文章讀懂ArrayList這一篇就夠了有講，ArrayList基於索引結構，元素是在堆空間連續存儲的地址，查找元素不用遍歷，所花費時間不多。而LinkedList中元素是在堆空間中不連續，經過prev、next指針相連的。
持續輸出高質量乾貨，歡迎關注公衆號：Duffy說碼
- 1. 讀懂ArrayList這一篇就夠了
- 2. 讀懂webpack4，看這一篇就夠了
- 3. LinkedList詳解，看這篇就夠了
- 4. 看懂 Serverless SSR，這一篇就夠了！
- 5. 看懂 Serverless，這一篇就夠了
- 6. 圖解Word2vec，讀這一篇就夠了
- 7. Redis入門，讀這一篇就夠了
- 8. 瞭解TrustZone，讀了這篇就夠了
- 9. 【Redis系列】：讀懂redis這一篇就夠了！
- 10. BERT大火卻不懂Transformer？讀這一篇就夠了
- 更多相關文章...
- • RSS 閱讀器 - RSS 教程
- • 一對一關聯查詢 - MyBatis教程
- • 再有人問你分佈式事務，把這篇扔給他
- • 三篇文章瞭解 TiDB 技術內幕——說存儲
-
每一个你不满意的现在，都有一个你没有努力的曾经。