死磕Java之聊聊LinkedList源码(基于JDK1.8)
生活随笔
收集整理的這篇文章主要介紹了
死磕Java之聊聊LinkedList源码(基于JDK1.8)
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
工作快一年了，近期打算研究一下JDK的源碼，也就因此有了死磕java系列
LinkedList 是一個繼承于AbstractSequentialList的雙向鏈表，鏈表不需要capacity的設定，它也可以被當作堆棧、隊列或雙端隊列進行操作。
LinkedList 實現 List 接口，能對它進行隊列操作，提供了相關的添加、刪除、修改、遍歷等功能。
LinkedList 實現 Deque 接口，即能將LinkedList當作雙端隊列使用。
LinkedList 實現了Cloneable接口，即覆蓋了函數clone()，能克隆。
LinkedList 實現java.io.Serializable接口，這意味著LinkedList支持序列化，能通過序列化去傳輸，包括網絡傳輸與本地文件序列化。
LinkedList 是非同步的，如若要在并發情況下使用建議選取java.util.concurrent包下的集合類型。
LinkedList的UML圖
LinkedList的成員變量及其含義
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0;
/**
* 指向頭指針的節點.
* transient關鍵字掃盲，在實現Serilizable接口后，
* 將不需要序列化的屬性前添加關鍵字transient，
* 序列化對象的時候，這個屬性就不會序列化到指定的目的地中
*/
transient Node<E> first;
/**
* 指向尾節點。
*/
transient Node<E> last;
/**
* 構造方法的空實現。
*/
public LinkedList() {
}
/**
* 按照集合迭代器返回的順序構造包含指定集合元素的列表。
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(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;
}
}
}
聊聊LinkedList的主要方法實現
我們主要看研究一下下面的幾個方法，LinkedList其他方法都是通過調用這幾個方法來實現功能，包括LinkedList的雙端隊列的方法也是。
/**
* 在鏈表頭部插入元素.
*/
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++;
}
/**
* 在鏈表尾部插入元素.
*/
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++;
}
/**
* 移除鏈表的頭部元素.
*/
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 將元素置為空，讓jvm在gc時回收資源
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
/**
* 移除鏈表的尾部元素.
*/
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;
}
/**
* 移除某一個節點元素.
*/
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;
}
/**
* 通過indexOf方法來定位給定的元素，若LinkedList中存在元素則返回該元素對應的index，
* 反之返回-1.
*/
public boolean contains(Object o) {
return indexOf(o) != -1;
}
/**
* 在鏈表尾部追加元素.
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 移除鏈表中的指定元素，分兩種情況進行處理，當元素為空時與元素不為空時，時間復雜度為O(n).
*/
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;
}
/**
* 將一個集合的所有元素追加到鏈表的尾部.
*/
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/**
* 將指定集合中的所有元素插入到該列表中，從指定位置開始。將當前在該位置的元素（如果有的話）
* 和任何后續元素向右移動（增加它們的索引）。新元素將以指定集合的迭代器返回的順序出現在列表中。
*/
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
/**
* 清空鏈表.
*/
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
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++;
}
// Positional Access Operations 以下是位置訪問操作
/**
* 獲取鏈表中對應索引的節點，時間復雜度為O(n)
*/
public E get(int index) {
// 檢查index是否越界
checkElementIndex(index);
return node(index).item;
}
/**
* 更新對應index的元素，并返回舊值，時間復雜度為O(n).
*/
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
/**
* 在指定索引添加元素，時間復雜度為O(1).
*/
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
/**
* 移除指定索引的元素，時間復雜度為O(1).
*/
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
* 查找指定index位置的元素.
*/
Node<E> node(int index) {
// assert isElementIndex(index);
// 在查找對應index位置的元素的時候，java開發人員做了一層優化
// 當index大于size的一半時從前向后查
// 當index小于size的一半時從后向前查
// 這樣的話時間復雜度就變成了index/2
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;
}
}
// Search Operations
/**
* 查找指定元素的index，從前向后查
*/
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;
}
/**
* 查找指定元素的index，從后向前查
*/
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;
}
動手實現LinkedList
由于代碼過長，故不在此處一一貼出來，感興趣的小伙伴可以到我的github查看[github]: https://github.com/haifeiWu/interview-collect/tree/master/src/main/java/com/haifeiwu/interview/structure/list
小結
與ArrayList相比，LinkedList的長處在于當頻繁的增加或者刪除元素時效率會很高，但是LinkedList空間占用比較大，是一種典型的用空間換時間方案，在我們平時做代碼優化時這也不失是種折中的方案。
LinkedList并發插入時節點覆蓋的問題，就是當多個線程同時獲取到相同的尾節點的時候，然后多個線程同時在此尾節點后面插入數據的時候會出現數據覆蓋的問題，因此在并發量大的情況下應該使用java的加鎖機制，或者采用java.util.concurrent包下的集合類型。
總結
以上是生活随笔為你收集整理的死磕Java之聊聊LinkedList源码(基于JDK1.8)的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 美国出现罕见绿色天空：人眼所见一片翠绿
- 下一篇： 负优化？三星手机应用更新 删除货币汇率转