Java集合之LinkedList源碼剖析(jdk1.8)
文章目錄
1、簡介
LinkedList底層基於雙向鏈表，增刪快，插入慢，還可以作爲隊列或者棧來使用。
繼承圖譜如下：
LinkedList實現了List、Serializable、Cloneable、Deque等接口。
LinkedList實現了Cloneable，可以被克隆。
LinkedList實現了Serializable，可以被序列化。
LinkedList實現了Deque接口，能作爲隊列、棧使用。
2、源碼剖析
1、屬性
LinkedList的屬性非常簡單，因爲基於鏈表，所以內部有一個Node類。
只有三個主要屬性。
//元素數量
transient int size = 0;
//鏈表頭節點
transient Node<E> first;
//鏈表尾節點
transient Node<E> last;
//內部類
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;
}
}
2、內部類
除了Node類外，內部還有三個和迭代器有關的內部類。
其中較爲常用的是ListItr類，該類繼承自ListIterator，可以向前向後遍歷數據。
通過LinkedList的listIterator(int index) 方法獲得。
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
private class ListItr implements ListIterator<E> {
//略去
}
除了listIterator迭代器外，也可以使用iterator這個Collection的迭代器。
LinkedList海域兩個迭代器基本不使用。
3、構造方法
有兩個構造方法,都很簡單。
由於基於鏈表，所以構造方法可以不用指定空間。
在增加元素的時候再使用已有節點連接新節點。
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
//從尾節點後加入集合c,組成新鏈表
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//通過索引，將集合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;
}
4、鏈表方法
這部分方法多數是用於對內部鏈表進行維護的方法。
對內部鏈表進行增刪改查。
node(int index)方法(查操作)
根據索引獲得對應節點，使用折半查找。
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;
}
}
link系列方法（增操作）
link方法是對鏈表進行增加操作。
可以從頭部、尾部、任意位置之前添加。
//從頭部添加
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++;
}
ulink系列方法(刪操作)
ulink系列方法用於刪除節點。
//刪除首節點，此處f必須是首節點
private E unlinkFirst(Node<E> f) {
//這兩個用於暫存f內容
final E element = f.item;
final Node<E> next = f.next;
//這兩個是用於輔助Gc的
f.item = null;
f.next = null;
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
//刪除尾節點，l必須是尾節點
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) {
//默認x爲中間節點，暫存x內容
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;
}
set方法(改操作)
更新的方法直接就可以從外部訪問。
//通過索引更新元素
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
5、List方法
這部分方法從外部就可以訪問，基於內部鏈表。
get方法(查)
通過node方法執行get系列方法。
以及一個indexOf方法。
//通過索引獲取元素
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//獲取頭節點元素
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
//獲取尾節點元素
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
//通過元素獲取索引
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;
}
add方法(增操作)
add方法用於加入元素，在構造方法中使用過addAll方法。
//從尾部添加
public boolean add(E e) {
linkLast(e);
return true;
}
//從指定位置添加
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//從頭部加入
public void addFirst(E e) {
linkFirst(e);
}
//同樣是從尾部加入
public void addLast(E e) {
linkLast(e);
}
remove方法(刪)
刪除方法，調用了unlink系列方法，在覈心方法中已有。
//從頭部刪除元素
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
//從尾部刪除元素
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//刪除指定元素
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;
}
6、其他方法
這部分方法多是對各種接口的實現。
toArray方法
Collection接口的實現，將集合轉化爲數組。
//轉換爲Object類型的數組
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
//轉換爲T類型數組，T必須是LinkedList的泛型
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
//將鏈表最後一個元素置空
if (a.length > size)
a[size] = null;
return a;
}
push/pop/peek方法
這是對Deque接口的實現，可以充當棧操作。
//這裏入棧出棧都從頭部操作，這樣不用每次都遍歷鏈表
public void push(E e) {
addFirst(e);
}
public E pop() {
return removeFirst();
}
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
3、總結
（1）LinkedList底層基於雙鏈表，增刪快，查詢慢；
（2）LinkedList還是一個雙端隊列，具有隊列、雙端隊列、棧的特性；
（3）LinkedList線程不安全。
（4）LinkedList有多種迭代器，支持向前向後遍歷。