Java Collection框架 - LinkedList
基于jdk1.8
簡介
LinkedList采用鏈表作為內部數據結構。它的新增和刪除操作的時間復雜度都是O(1)，查找跟修改的時間復雜度是O(n)。但在插入和刪除節點之前必須先找到該節點，因此除了頭尾的插入和刪除操作是O(1)外，其它節點最差的情況下是O(n)。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;
}
}
LinkedList的每個節點都包括三個屬性：前后節點引用和節點的值。LinkedList還用first和last兩個屬性記錄了鏈表的頭尾節點
主要屬性與方法列表
//鏈表容量
size : int
//鏈表頭
first : Node<E>
//鏈表尾
last : Node<E>
getFirst() : E
getLast() : E
removeFirst() : E
removeLast() : E
addFirst(E) : void
addLast(E) : void
contains(Object) : boolean
size() : int
add(E) : boolean
remove(Object) : boolean
addAll(Collection<? extends E>) : boolean
addAll(int, Collection<? extends E>) : boolean
clear() : void
get(int) : E
set(int, E) : E
add(int, E) : void
remove(int) : E
indexOf(Object) : int
lastIndexOf(Object) : int
peek() : E
element() : E
poll() : E
remove() : E
offer(E) : boolean
offerFirst(E) : boolean
offerLast(E) : boolean
peekFirst() : E
peekLast() : E
pollFirst() : E
pollLast() : E
push(E) : void
pop() : E
removeFirstOccurrence(Object) : boolean
removeLastOccurrence(Object) : boolean
listIterator(int) : ListIterator<E>
descendingIterator() : Iterator<E>
clone() : Object
toArray() : Object[]
toArray(T[]) <T> : T[]
主要代碼分析
由于LinkedList同時實現了List和Deque兩個接口，因此LinkedList中的方法可以大致分為兩種：
- List系：方法名中包括get、add、set、remove等字眼
- Deque系：方法名中包括peek、offer、push、pull、pop、first、last等字眼
- 查找
LinkedList提供了下列方法用于讀取鏈表節點：
* get(int index)
* getFirst()
* getLast()
* peek()
* peekFirst()
* peekLast()
* element() ==> getFirst()
其中getFirst()和peekFirst()、getLast()和peekLast()分別用于獲取鏈表的頭尾節點。getFirst()和getLast()在獲取節點時，如果鏈表為空，則會拋出NoSuchElementException，peekFirst()和peekLast()只會返回null值，不拋出異常。peek()與peekFirst()完全相同。element()內部調用的getFirst()
-
getFirst()：獲取鏈表的頭節點public E getFirst() { final Node<E> f = first; if (f == null) throw new NoSuchElementException(); return f.item; } -
getLast()：獲取鏈表的尾節點public E getLast() { final Node<E> l = last; if (l == null) throw new NoSuchElementException(); return l.item; } -
peek()/peekFirst()：獲取鏈表頭節點public E peek/peekFirst() { final Node<E> f = first; return (f == null) ? null : f.item; } -
peekLast()：獲取鏈表尾節點public E peekLast() { final Node<E> l = last; return (l == null) ? null : l.item; } -
get(int index)：獲取指定索引處的節點public E get(int index) { //檢查index值是否合法 checkElementIndex(index); return node(index).item; }get(int index)依賴node(int index)，實際上，在LinkedList中每個與索引有關的方法都依賴node(int index)。下面是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; } }node(int index)使用二分查找來提高查找效率
- 增加
LinkedList提供了下列方法用于向鏈表中添加節點：
* add(E e) ==> linkLast(E e)
* add(int index, E e)
* addFirst(E e) ==> linkFirst(E e)
* addLast(E e) ==> linkLast(E e)
* offer(E e) ==> add(E e)
* offerFirst(E e) ==> addFirst(E e)
* offerLast(E e) ==> addLast(E e)
* push(E e) ==> addFirst(E e)
* addAll(Collection<? extends E> c) ==> addAll(int index, Collection<? extends E> c)
* addAll(int index, Collection<? extends E> c)
從上面可以看出LinkedList有很多種添加方法，但實際上大多數方法依賴linkFirst(E e)和linkLast(E e)作為實現。根據返回值可以分為兩類：
* 沒有返回值的方法，如addFirst(E e)、addLast(E e)和push(E e)
* 返回boolean的方法，如add(E e)、offer(E e)、offerFirst(E e)和offerLast(E e)
既然linkFirst(E e)跟linkLast(E e)這么重要，就先看它們的代碼
* linkFirst(E e)：向鏈表頭添加節點
```java
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++;
}
```
* ``linkLast(E e)``：向鏈表尾添加節點
```java
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++;
}
```
那些依賴linkFirst(E e)跟linkLast(E e)的方法就不一一列出了，直接看別的方法
-
add(int index, E e)：將節點添加到指定索引位置public void add(int index, E element) { //檢查index值是否合法 checkPositionIndex(index); if (index == size) linkLast(element); else linkBefore(element, node(index)); }可以看到，
add(int index, E e)是依賴linkBefore(E e, Node<E> succ)實現的，直接看linkBefore(E e, Node<E> succ)的代碼：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++; }
- 修改
LinkedList提供了set(int index, E e)用于修改鏈表
-
set(int index, E e)：修改指定索引對應節點的值public E set(int index, E element) { //檢查index值是否合法 checkElementIndex(index); //獲取節點 Node<E> x = node(index); //修改節點值 E oldVal = x.item; x.item = element; return oldVal; }set(int index, E e)中沒有modCount++這句代碼（作用是更新鏈表的修改計數器，與ConcurrentModificationException異常有關），因為該方法并沒有改變鏈表的結構，只是更新節點的值
- 刪除
LinkedList提供了下列方法用于刪除鏈表中的節點：
* remove(int index)
* remove(Object o)
* remove() ==> removeFirst()
* removeFirst() ==> unlinkFirst(Node<E> n)
* removeLast() ==> unlinkLast(Node<E> n)
* poll() ==> unlinkFirst(Node<E> n)
* pollFirst() ==> unlinkFirst(Node<E> n)
* pollLast() ==> unlinkLast(Node<E> n)
* pop() ==> removeFirst()
* removeFirstOccurrence(Object o) ==> remove(Object o)
* removeLastOccurrence(Object o)
與添加類似，大多數方法依賴unlinkFirst(Node<E> n)跟unlinkLast(Node<E> n)，可以分為兩種：
* 拋出NoSuchElementException異常，如remove()、removeFirst()、removeLast()和pop()
* 不拋出異常，如poll()、pollFirst()和pollLast()
unlinkFirst(Node<E> n)跟unlinkLast(Node<E> n)的代碼：
* unlinkFirst(Node<E> n)：刪除頭節點
```java
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;
}
```
* ``unlinkLast(Node<E> n)``：刪除尾節點
```java
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;
}
```
-
remove(int index)：根據索引刪除節點public E remove(int index) { //檢查index值是否合法 checkElementIndex(index); return unlink(node(index)); }remove(int index)內部使用unlink(Node<E> n)作為實現，unlink(Node<E> n)的代碼如下：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)：根據節點值刪除節點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; }可以看到
remove(Object o)其實也是依賴unlink(Node<E> n)實現的。removeFirstOccurrence(Object o)則是依賴remove(Object o)實現的所以就不列出了 -
removeLastOccurrence(Object o)：刪除倒數第一個找到的節點public boolean removeLastOccurrence(Object o) { if (o == null) { for (Node<E> x = last; x != null; x = x.prev) { if (x.item == null) { unlink(x); return true; } } } else { for (Node<E> x = last; x != null; x = x.prev) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; }removeLastOccurrence(Object o)與remove(Object o)的實現幾乎相同，只不過一個是倒序查找，一個是正序查找
總結
LinkedList雖然實現了很多操作鏈表的方法，但大多數都依賴以下幾個方法：
linkFirst(E e)linkLast(E e)linkBefore(E e, Node<E> succ)unlinkFirst(Node<E> f)unlinkLast(Node<E> l)unlink(Node<E> x)node(int index)
LinkedList通過這些方法，將實際數據結構與接口方法實現分離開來
