LinkedList源碼解析
LinkedList的本質是雙鏈表。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
- 實現了List接口表明需要實現List中的set,get等方法;
- 實現了Deque接口表明LinkedList實現了雙端隊列的方法;
- 實現了Clonable接口表明可以被clone;
- 實現了Serializable接口表明可以被序列化。
LinkedList鏈表結點結構
LinkedList的靜態內部類。
//鏈表節點的結構,雙向鏈表
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;
}
}
成員變量
//記錄鏈表的長度
transient int size = 0;
/**
* Pointer to first node.
* 一定滿足: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
//指向頭節點的指針
transient Node<E> first;
/**
* Pointer to last node.
* 一定滿足: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
//指向尾結點的指針
transient Node<E> last;
構造方法
//空的構造方法
public LinkedList() {
}
//將集合c中的元素插入到鏈表中
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
成員方法
插入元素
- 頭插法
//在表頭插入一個元素(頭插法)
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
//當前鏈表爲空,last指針指向newNode
if (f == null)
last = newNode;
else
//如果不爲空,則將f.prev指向newNode
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;
//l==null,表明鏈表爲空
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
- 在某個結點前插入元素
//在非空的succ結點前插入元素e。雙向鏈表的插入操作
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
first = next;
//next==null,說明刪除頭結點後,鏈表爲null
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;
}
- 刪除鏈表中的任意結點x
//刪除結點x
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;
//如果prev==null,說明x爲頭結點
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;
}
上述鏈表的插入和刪除操作是LinkedList的核心,我們常用的add(),remove()等方法均是調用上述方法完成的。
然後,我們再看LinkedList的get()和set()方法
get()方法
//獲取鏈表index處的節點
public E get(int index) {
//檢查index是否越界
checkElementIndex(index);
//找到index位置處的結點,並返回該結點的值
return node(index).item;
}
set()方法
//將index位置的節點的元素設置爲element
public E set(int index, E element) {
checkElementIndex(index);
//找到index位置處的結點
Node<E> x = node(index);
E oldVal = x.item;
//將element的值賦給該結點
x.item = element;
return oldVal;
}
看完上述源代碼,我們會發現,get和set操作都是通過node()方法完成操作的。下面我們看一下node()方法的代碼。
node(int 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;
}
}
鏈表的查找操作
//鏈表中是否包含元素o,如果是,返回true,否則返回false
public boolean contains(Object o) {
//調用indexOf()方法
return indexOf(o) != -1;
}
//查找操作,返回元素o在鏈表中第一次出現的位置,如果不在鏈表中,則返回-1
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;
}
前面我們說過,LinkedList實現了Deque接口,所以,LinkedList擁有雙端隊列的操作。
隊列的操作
- 獲取隊頭元素
//獲得頭結點數據,允許爲null.一般用於獲取隊頭元素
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//雙端隊列
//獲取隊頭元素
//獲取隊頭元素,允許爲null
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//獲取隊尾元素
//獲取隊尾元素,允許爲null
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
- 入隊操作
//等價於add(e),一般用於入隊操作
public boolean offer(E e) {
return add(e);
}
//雙端隊列
//從隊頭入隊
//等價於addFirst(e),一般用於從隊頭入隊
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//從對尾入隊
//等價於addLast(e),一般用於從隊尾入隊
public boolean offerLast(E e) {
addLast(e);
return true;
}
- 出隊操作
//獲得頭結點數據,並刪除頭結點,允許爲null。一般用於出隊操作
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 pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
LinkedList除了集成了隊列的功能,還集成了棧的操作。棧的操作比較簡單,如下。
棧的操作
- 出棧
//出棧
public E pop() {
return removeFirst();
}
- 入棧
//入棧
public void push(E e) {
addFirst(e);
}
到此,LinkedList的源碼大致分析完畢。by the way,LinkedList也是非線程安全的,同時也使用了fail-fast機制。