LinkedList源碼閱讀分析
LinkedList的底層是一個雙向鏈表結構，所以他具備鏈表的特性，插入刪除快，查找慢。更有意思的是LinkedList能夠認爲是集鏈表與隊列與一身的一個實現類。下面經過閱讀源碼來理解一下。java
實際結構
雙向鏈表
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;
}
}
複製代碼
LinkedList內部維護一個Node類，從代碼上可知該類表示一個雙向鏈表。node
成員變量
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
複製代碼
size 表示當前鏈表的大小， first表示頭節點 last表示尾節點緩存
構造函數
public LinkedList() {
}
複製代碼
默認無參構造函數，什麼都不作。函數
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
複製代碼
經過一個集合來構造，首先建立一個空的本身，而後將集合c追加到本身的末尾。優化
添加元素
添加
public boolean add(E e) {
linkLast(e);
return true;
}
複製代碼
追加到鏈表末尾。this
指定位置添加
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
複製代碼
邏輯：校驗index是否合法，不然拋出越界異常。若是index是最後一個位置，那麼調用linkLast方法追加到原鏈表最後，不然插在指定位置。 這裏有兩個私有方法須要看一下spa
Node<E> node(int index) {
// assert isElementIndex(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;
}
}
複製代碼
根據索引index，獲取指定位置的節點。這裏作了一個優化，若是index在前半部分，那麼就從first開始往下找，若是index在後半部分，那就從last往前開始找。指針
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++;
}
複製代碼
在succ節點以前插入一個節點，該節點元素值爲e。 邏輯：先找到原succ節點的前一個節點，緩存下來，記爲pred。新建一個節點，該 節點的元素值爲e，prev指針指向pred節點,next指針指向succ節點。succ節點的prev指針指向新節點. 此時須要判斷，若是原來succ節點是頭結點，那麼新添加的節點爲新的first頭結點。不然的話， 原來的pred節點的prev指針指向我這個新節點，那麼我就插入到了pred節點和succ節點的中間。code
移除元素
指定位置移除
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
複製代碼
來看私有方法 unlink索引
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;
}
複製代碼
邏輯：先緩存下我這個節點的prev和next節點. 若是原來我是頭節點first，那麼只需把first節點指向個人next，我就從原始鏈表中脫離了。不然的話個人prev節點的next指針指向個人next節點。
若是原來我是尾節點last，那麼只需把last節點指向個人prev，我就從原始鏈表中脫離了。不然的話，個人next節點的prev指針指向個人prev節點.
脫離鏈表後，須要把個人元素置爲null，不然會形成內存泄露。
指定元素移除
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;
}
複製代碼
邏輯類似，經過從頭節點遍歷的方式查找到要刪除的第一個節點，而後調用unlink方法進行移除.
查找
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
複製代碼
順序查找，找到第一個就返回該值索引，若是沒找到就返回-1.
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
複製代碼
倒序查找，找到第一個就返回該值索引，若是沒找到就返回-1.
獲取
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
複製代碼
獲取指定位置的元素值。
修改
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
複製代碼
修改指定位置的元素值，返回舊值。
以上的增長、刪除、查找接口都是實現List接口，而LinkedList不只實現了List接口，還實現的Deque接口，雙向隊列。所以它做爲一個雙向隊列，還提供了相應的增刪查改接口。
隊列的特色是先入先出。因此不會提供指定位置的增刪查改功能，只能讀寫頭尾節點。
添加
添加到開頭
public void addFirst(E e) {
linkFirst(e);
}
複製代碼
public boolean offer(E e) {
return add(e);
}
複製代碼
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
複製代碼
public void push(E e) {
addFirst(e);
}
複製代碼
私有方法 linkFirst
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
複製代碼
邏輯：新建一個節點，該節點的元素值爲e,prev指針爲null，next指針爲原來頭結點。而後再把first頭結點指針指向新節點。此處須要注意的是若是原來沒有節點，當前新增節點爲第一個節點，那麼last指針也指向該節點。
添加到末尾
public void addLast(E e) {
linkLast(e);
}
複製代碼
私有方法 linkLast
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++;
}
複製代碼
邏輯：新建一個節點，該節點的元素值爲e，prev指針爲原來的尾節點，next指針爲null，而後再把last指針指向該節點。此處須要注意的是，若是原來沒有節點，當前新增節點爲第一個節點，那麼first指針也指向該節點。
移除元素
移除頭節點
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
複製代碼
public E pop() {
return removeFirst();
}
複製代碼
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
複製代碼
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
複製代碼
來看私有方法unlinkFirst
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;
}
複製代碼
邏輯：要移除一個節點，則將該節點的prev指針、next指針都置爲null，那麼當前節點就從原鏈表中脫離了。同時要將這個節點的元素置爲null，不然會形成內存泄露. 再將first節點置爲原節點的next。此時須要注意若是原來只有一個節點，移除以後last節點變成了null.
移除尾節點
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
複製代碼
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
複製代碼
來看私有方法unlinkLast
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
複製代碼
相同的邏輯，該節點的prev指針、next指針均置爲null，則該節點從原鏈表中脫離出來，此時須要將該節點的元素置爲null，避免內存泄露。 同時須要注意若是原鏈表只有這一個節點，那麼移除該節點後，first節點指向null。
讀取數據
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
複製代碼
public E element() {
return getFirst();
}
複製代碼
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
複製代碼
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
複製代碼
- 1. JDK源碼閱讀--LinkedList
- 2. LinkedList源碼分析
- 3. 源碼分析|LinkedList
- 4. LinkedList 源碼分析
- 5. 源碼分析——LinkedList
- 6. 源碼分析------LinkedList
- 7. rxjava2源碼分析閱讀
- 8. ArrayList源碼閱讀分析
- 9. Vuex源碼閱讀分析
- 10. AtomicInteger 源碼分析閱讀
- 更多相關文章...
- • RSS 閱讀器 - RSS 教程
- • PHP 實例 - AJAX RSS 閱讀器 - PHP教程
- • 互聯網組織的未來：剖析GitHub員工的任性之源
- • Java Agent入門實戰（二）-Instrumentation源碼概述
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. JDK源碼閱讀--LinkedList
- 2. LinkedList源碼分析
- 3. 源碼分析|LinkedList
- 4. LinkedList 源碼分析
- 5. 源碼分析——LinkedList
- 6. 源碼分析------LinkedList
- 7. rxjava2源碼分析閱讀
- 8. ArrayList源碼閱讀分析
- 9. Vuex源碼閱讀分析
- 10. AtomicInteger 源碼分析閱讀