概要
前面，我們已經學習了ArrayList，並瞭解了fail-fast機制。這一章我們接著學習List的實現類——LinkedList。
和學習ArrayList一樣，接下來呢，我們先對LinkedList有個整體認識，然後再學習它的原始碼；最後再通過例項來學會使用LinkedList。
第1部分 LinkedList介紹
LinkedList簡介
LinkedList 是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。
LinkedList 實現 List 介面，能對它進行佇列操作。
LinkedList 實現 Deque 介面，即能將LinkedList當作雙端佇列使用。
LinkedList 實現了Cloneable介面，即覆蓋了函式clone()，能克隆。
LinkedList 實現java.io.Serializable介面，這意味著LinkedList支援序列化，能通過序列化去傳輸。
LinkedList 是非同步的。
LinkedList建構函式
// 預設建構函式
LinkedList()
// 建立一個LinkedList，保護Collection中的全部元素。
LinkedList(Collection<? extends E> collection)
複製程式碼LinkedList的API
LinkedList的API
boolean add(E object)
void add(int location, E object)
boolean addAll(Collection<? extends E> collection)
boolean addAll(int location, Collection<? extends E> collection)
void addFirst(E object)
void addLast(E object)
void clear()
Object clone()
boolean contains(Object object)
Iterator<E> descendingIterator()
E element()
E get(int location)
E getFirst()
E getLast()
int indexOf(Object object)
int lastIndexOf(Object object)
ListIterator<E> listIterator(int location)
boolean offer(E o)
boolean offerFirst(E e)
boolean offerLast(E e)
E peek()
E peekFirst()
E peekLast()
E poll()
E pollFirst()
E pollLast()
E pop()
void push(E e)
E remove()
E remove(int location)
boolean remove(Object object)
E removeFirst()
boolean removeFirstOccurrence(Object o)
E removeLast()
boolean removeLastOccurrence(Object o)
E set(int location, E object)
int size()
<T> T[] toArray(T[] contents)
Object[] toArray()
複製程式碼AbstractSequentialList簡介
在介紹LinkedList的原始碼之前，先介紹一下AbstractSequentialList。畢竟，LinkedList是AbstractSequentialList的子類。
AbstractSequentialList 實現了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)這些函式。這些介面都是隨機訪問List的，LinkedList是雙向連結串列；既然它繼承於AbstractSequentialList，就相當於已經實現了“get(int index)這些介面”。
此外，我們若需要通過AbstractSequentialList自己實現一個列表，只需要擴充套件此類，並提供 listIterator() 和 size() 方法的實現即可。若要實現不可修改的列表，則需要實現列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。
第2部分 LinkedList資料結構
LinkedList的繼承關係
java.lang.Object
↳ java.util.AbstractCollection<E>
↳ java.util.AbstractList<E>
↳ java.util.AbstractSequentialList<E>
↳ java.util.LinkedList<E>
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}
複製程式碼LinkedList與Collection關係如下圖：
LinkedList的本質是雙向連結串列。
(01) LinkedList繼承於AbstractSequentialList，並且實現了Dequeue介面。
(02) LinkedList包含兩個重要的成員：header 和 size。
header是雙向連結串列的表頭，它是雙向連結串列節點所對應的類Entry的例項。Entry中包含成員變數： previous, next, element。其中，previous是該節點的上一個節點，next是該節點的下一個節點，element是該節點所包含的值。
size是雙向連結串列中節點的個數。
第3部分 LinkedList原始碼解析(基於JDK1.6.0_45)
為了更瞭解LinkedList的原理，下面對LinkedList原始碼程式碼作出分析。
在閱讀原始碼之前，我們先對LinkedList的整體實現進行大致說明：
LinkedList實際上是通過雙向連結串列去實現的。既然是雙向連結串列，那麼它的順序訪問會非常高效，而隨機訪問效率比較低。
既然LinkedList是通過雙向連結串列的，但是它也實現了List介面{也就是說，它實現了get(int location)、remove(int location)等“根據索引值來獲取、刪除節點的函式”}。LinkedList是如何實現List的這些介面的，如何將“雙向連結串列和索引值聯絡起來的”？
實際原理非常簡單，它就是通過一個計數索引值來實現的。例如，當我們呼叫get(int location)時，首先會比較“location”和“雙向連結串列長度的1/2”；若前者大，則從連結串列頭開始往後查詢，直到location位置；否則，從連結串列末尾開始先前查詢，直到location位置。
這就是“雙線連結串列和索引值聯絡起來”的方法。
好了，接下來開始閱讀原始碼(只要理解雙向連結串列，那麼LinkedList的原始碼很容易理解的)。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
// 連結串列的表頭，表頭不包含任何資料。Entry是個連結串列類資料結構。
private transient Entry<E> header = new Entry<E>(null, null, null);
// LinkedList中元素個數
private transient int size = 0;
// 預設建構函式：建立一個空的連結串列
public LinkedList() {
header.next = header.previous = header;
}
// 包含“集合”的建構函式:建立一個包含“集合”的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
// 獲取LinkedList的第一個元素
public E getFirst() {
if (size==0)
throw new NoSuchElementException();
// 連結串列的表頭header中不包含資料。
// 這裡返回header所指下一個節點所包含的資料。
return header.next.element;
}
// 獲取LinkedList的最後一個元素
public E getLast() {
if (size==0)
throw new NoSuchElementException();
// 由於LinkedList是雙向連結串列；而表頭header不包含資料。
// 因而，這裡返回表頭header的前一個節點所包含的資料。
return header.previous.element;
}
// 刪除LinkedList的第一個元素
public E removeFirst() {
return remove(header.next);
}
// 刪除LinkedList的最後一個元素
public E removeLast() {
return remove(header.previous);
}
// 將元素新增到LinkedList的起始位置
public void addFirst(E e) {
addBefore(e, header.next);
}
// 將元素新增到LinkedList的結束位置
public void addLast(E e) {
addBefore(e, header);
}
// 判斷LinkedList是否包含元素(o)
public boolean contains(Object o) {
return indexOf(o) != -1;
}
// 返回LinkedList的大小
public int size() {
return size;
}
// 將元素(E)新增到LinkedList中
public boolean add(E e) {
// 將節點(節點資料是e)新增到表頭(header)之前。
// 即，將節點新增到雙向連結串列的末端。
addBefore(e, header);
return true;
}
// 從LinkedList中刪除元素(o)
// 從連結串列開始查詢，如存在元素(o)則刪除該元素並返回true；
// 否則，返回false。
public boolean remove(Object o) {
if (o==null) {
// 若o為null的刪除情況
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
// 若o不為null的刪除情況
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
// 將“集合(c)”新增到LinkedList中。
// 實際上，是從雙向連結串列的末尾開始，將“集合(c)”新增到雙向連結串列中。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
// 從雙向連結串列的index開始，將“集合(c)”新增到雙向連結串列中。
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Object[] a = c.toArray();
// 獲取集合的長度
int numNew = a.length;
if (numNew==0)
return false;
modCount++;
// 設定“當前要插入節點的後一個節點”
Entry<E> successor = (index==size ? header : entry(index));
// 設定“當前要插入節點的前一個節點”
Entry<E> predecessor = successor.previous;
// 將集合(c)全部插入雙向連結串列中
for (int i=0; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;
// 調整LinkedList的實際大小
size += numNew;
return true;
}
// 清空雙向連結串列
public void clear() {
Entry<E> e = header.next;
// 從表頭開始，逐個向後遍歷；對遍歷到的節點執行一下操作：
// (01) 設定前一個節點為null
// (02) 設定當前節點的內容為null
// (03) 設定後一個節點為“新的當前節點”
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
header.next = header.previous = header;
// 設定大小為0
size = 0;
modCount++;
}
// 返回LinkedList指定位置的元素
public E get(int index) {
return entry(index).element;
}
// 設定index位置對應的節點的值為element
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
// 在index前新增節點，且節點的值為element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
// 刪除index位置的節點
public E remove(int index) {
return remove(entry(index));
}
// 獲取雙向連結串列中指定位置的節點
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
// 獲取index處的節點。
// 若index < 雙向連結串列長度的1/2,則從前先後查詢;
// 否則，從後向前查詢。
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
// 從前向後查詢，返回“值為物件(o)的節點對應的索引”
// 不存在就返回-1
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element==null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
}
// 從後向前查詢，返回“值為物件(o)的節點對應的索引”
// 不存在就返回-1
public int lastIndexOf(Object o) {
int index = size;
if (o==null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element==null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
}
// 返回第一個節點
// 若LinkedList的大小為0,則返回null
public E peek() {
if (size==0)
return null;
return getFirst();
}
// 返回第一個節點
// 若LinkedList的大小為0,則丟擲異常
public E element() {
return getFirst();
}
// 刪除並返回第一個節點
// 若LinkedList的大小為0,則返回null
public E poll() {
if (size==0)
return null;
return removeFirst();
}
// 將e新增雙向連結串列末尾
public boolean offer(E e) {
return add(e);
}
// 將e新增雙向連結串列開頭
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
// 將e新增雙向連結串列末尾
public boolean offerLast(E e) {
addLast(e);
return true;
}
// 返回第一個節點
// 若LinkedList的大小為0,則返回null
public E peekFirst() {
if (size==0)
return null;
return getFirst();
}
// 返回最後一個節點
// 若LinkedList的大小為0,則返回null
public E peekLast() {
if (size==0)
return null;
return getLast();
}
// 刪除並返回第一個節點
// 若LinkedList的大小為0,則返回null
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
}
// 刪除並返回最後一個節點
// 若LinkedList的大小為0,則返回null
public E pollLast() {
if (size==0)
return null;
return removeLast();
}
// 將e插入到雙向連結串列開頭
public void push(E e) {
addFirst(e);
}
// 刪除並返回第一個節點
public E pop() {
return removeFirst();
}
// 從LinkedList開始向後查詢，刪除第一個值為元素(o)的節點
// 從連結串列開始查詢，如存在節點的值為元素(o)的節點，則刪除該節點
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
// 從LinkedList末尾向前查詢，刪除第一個值為元素(o)的節點
// 從連結串列開始查詢，如存在節點的值為元素(o)的節點，則刪除該節點
public boolean removeLastOccurrence(Object o) {
if (o==null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
// 返回“index到末尾的全部節點”對應的ListIterator物件(List迭代器)
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}
// List迭代器
private class ListItr implements ListIterator<E> {
// 上一次返回的節點
private Entry<E> lastReturned = header;
// 下一個節點
private Entry<E> next;
// 下一個節點對應的索引值
private int nextIndex;
// 期望的改變計數。用來實現fail-fast機制。
private int expectedModCount = modCount;
// 建構函式。
// 從index位置開始進行迭代
ListItr(int index) {
// index的有效性處理
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
// 若 “index 小於 ‘雙向連結串列長度的一半’”，則從第一個元素開始往後查詢；
// 否則，從最後一個元素往前查詢。
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}
// 是否存在下一個元素
public boolean hasNext() {
// 通過元素索引是否等於“雙向連結串列大小”來判斷是否達到最後。
return nextIndex != size;
}
// 獲取下一個元素
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();
lastReturned = next;
// next指向連結串列的下一個元素
next = next.next;
nextIndex++;
return lastReturned.element;
}
// 是否存在上一個元素
public boolean hasPrevious() {
// 通過元素索引是否等於0，來判斷是否達到開頭。
return nextIndex != 0;
}
// 獲取上一個元素
public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException();
// next指向連結串列的上一個元素
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
// 獲取下一個元素的索引
public int nextIndex() {
return nextIndex;
}
// 獲取上一個元素的索引
public int previousIndex() {
return nextIndex-1;
}
// 刪除當前元素。
// 刪除雙向連結串列中的當前節點
public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next==lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = header;
expectedModCount++;
}
// 設定當前節點為e
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
// 將e新增到當前節點的前面
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 判斷 “modCount和expectedModCount是否相等”，依次來實現fail-fast機制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
// 雙向連結串列的節點所對應的資料結構。
// 包含3部分：上一節點，下一節點，當前節點值。
private static class Entry<E> {
// 當前節點所包含的值
E element;
// 下一個節點
Entry<E> next;
// 上一個節點
Entry<E> previous;
/**
* 連結串列節點的建構函式。
* 引數說明：
* element —— 節點所包含的資料
* next —— 下一個節點
* previous —— 上一個節點
*/
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
// 將節點(節點資料是e)新增到entry節點之前。
private Entry<E> addBefore(E e, Entry<E> entry) {
// 新建節點newEntry，將newEntry插入到節點e之前；並且設定newEntry的資料是e
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
// 修改LinkedList大小
size++;
// 修改LinkedList的修改統計數：用來實現fail-fast機制。
modCount++;
return newEntry;
}
// 將節點從連結串列中刪除
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}
// 反向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
// 反向迭代器實現類。
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
// 反向迭代器是否下一個元素。
// 實際上是判斷雙向連結串列的當前節點是否達到開頭
public boolean hasNext() {
return itr.hasPrevious();
}
// 反向迭代器獲取下一個元素。
// 實際上是獲取雙向連結串列的前一個節點
public E next() {
return itr.previous();
}
// 刪除當前節點
public void remove() {
itr.remove();
}
}
// 返回LinkedList的Object[]陣列
public Object[] toArray() {
// 新建Object[]陣列
Object[] result = new Object[size];
int i = 0;
// 將連結串列中所有節點的資料都新增到Object[]陣列中
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}
// 返回LinkedList的模板陣列。所謂模板陣列，即可以將T設為任意的資料型別
public <T> T[] toArray(T[] a) {
// 若陣列a的大小 < LinkedList的元素個數(意味著陣列a不能容納LinkedList中全部元素)
// 則新建一個T[]陣列，T[]的大小為LinkedList大小，並將該T[]賦值給a。
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
// 將連結串列中所有節點的資料都新增到陣列a中
int i = 0;
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
if (a.length > size)
a[size] = null;
return a;
}
// 克隆函式。返回LinkedList的克隆物件。
public Object clone() {
LinkedList<E> clone = null;
// 克隆一個LinkedList克隆物件
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// 新建LinkedList表頭節點
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// 將連結串列中所有節點的資料都新增到克隆物件中
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
// java.io.Serializable的寫入函式
// 將LinkedList的“容量，所有的元素值”都寫入到輸出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// 寫入“容量”
s.writeInt(size);
// 將連結串列中所有節點的資料都寫入到輸出流中
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}
// java.io.Serializable的讀取函式：根據寫入方式反向讀出
// 先將LinkedList的“容量”讀出，然後將“所有的元素值”讀出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// 從輸入流中讀取“容量”
int size = s.readInt();
// 新建連結串列表頭節點
header = new Entry<E>(null, null, null);
header.next = header.previous = header;
// 從輸入流中將“所有的元素值”並逐個新增到連結串列中
for (int i=0; i<size; i++)
addBefore((E)s.readObject(), header);
}
}
複製程式碼總結：
(01) LinkedList 實際上是通過雙向連結串列去實現的。
它包含一個非常重要的內部類：Entry。Entry是雙向連結串列節點所對應的資料結構，它包括的屬性有：當前節點所包含的值，上一個節點，下一個節點。
(02) 從LinkedList的實現方式中可以發現，它不存在LinkedList容量不足的問題。
(03) LinkedList的克隆函式，即是將全部元素克隆到一個新的LinkedList物件中。
(04) LinkedList實現java.io.Serializable。當寫入到輸出流時，先寫入“容量”，再依次寫入“每一個節點保護的值”；當讀出輸入流時，先讀取“容量”，再依次讀取“每一個元素”。
(05) 由於LinkedList實現了Deque，而Deque介面定義了在雙端佇列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操作失敗時丟擲異常，另一種形式返回一個特殊值（null 或 false，具體取決於操作）。
總結起來如下表格：
第一個元素（頭部） 最後一個元素（尾部）
丟擲異常 特殊值 丟擲異常 特殊值
插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e)
移除 removeFirst() pollFirst() removeLast() pollLast()
檢查 getFirst() peekFirst() getLast() peekLast()
複製程式碼(06) LinkedList可以作為FIFO(先進先出)的佇列，作為FIFO的佇列時，下表的方法等價：
佇列方法 等效方法
add(e) addLast(e)
offer(e) offerLast(e)
remove() removeFirst()
poll() pollFirst()
element() getFirst()
peek() peekFirst()
複製程式碼(07) LinkedList可以作為LIFO(後進先出)的棧，作為LIFO的棧時，下表的方法等價：
棧方法 等效方法
push(e) addFirst(e)
pop() removeFirst()
peek() peekFirst()
複製程式碼第4部分 LinkedList遍歷方式
LinkedList遍歷方式
LinkedList支援多種遍歷方式。建議不要採用隨機訪問的方式去遍歷LinkedList，而採用逐個遍歷的方式。
(01) 第一種，通過迭代器遍歷。即通過Iterator去遍歷。
for(Iterator iter = list.iterator(); iter.hasNext();)
iter.next();
複製程式碼(02) 通過“`訪問遍歷LinkedList
int size = list.size();
for (int i=0; i<size; i++) {
list.get(i);
}
複製程式碼(03) 通過另外一種for迴圈來遍歷LinkedList
for (Integer integ:list)
;
複製程式碼(04) 通過**pollFirst()**來遍歷LinkedList
while(list.pollFirst() != null)
;
複製程式碼(05) 通過**pollLast()**來遍歷LinkedList
while(list.pollLast() != null)
;
複製程式碼(06) 通過**removeFirst()**來遍歷LinkedList
try {
while(list.removeFirst() != null)
;
} catch (NoSuchElementException e) {
}
複製程式碼(07) 通過**removeLast()**來遍歷LinkedList
try {
while(list.removeLast() != null)
;
} catch (NoSuchElementException e) {
}
複製程式碼測試這些遍歷方式效率的程式碼如下：
public class LinkedListThruTest {
public static void main(String[] args) {
// 通過Iterator遍歷LinkedList
iteratorLinkedListThruIterator(getLinkedList()) ;
// 通過快速隨機訪問遍歷LinkedList
iteratorLinkedListThruForeach(getLinkedList()) ;
// 通過for迴圈的變種來訪問遍歷LinkedList
iteratorThroughFor2(getLinkedList()) ;
// 通過PollFirst()遍歷LinkedList
iteratorThroughPollFirst(getLinkedList()) ;
// 通過PollLast()遍歷LinkedList
iteratorThroughPollLast(getLinkedList()) ;
// 通過removeFirst()遍歷LinkedList
iteratorThroughRemoveFirst(getLinkedList()) ;
// 通過removeLast()遍歷LinkedList
iteratorThroughRemoveLast(getLinkedList()) ;
}
private static LinkedList getLinkedList() {
LinkedList llist = new LinkedList();
for (int i=0; i<100000; i++)
llist.addLast(i);
return llist;
}
/**
* 通過快迭代器遍歷LinkedList
*/
private static void iteratorLinkedListThruIterator(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時間
long start = System.currentTimeMillis();
for(Iterator iter = list.iterator(); iter.hasNext();)
iter.next();
// 記錄結束時間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorLinkedListThruIterator：" + interval+" ms");
}
/**
* 通過快速隨機訪問遍歷LinkedList
*/
private static void iteratorLinkedListThruForeach(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時間
long start = System.currentTimeMillis();
int size = list.size();
for (int i=0; i<size; i++) {
list.get(i);
}
// 記錄結束時間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorLinkedListThruForeach：" + interval+" ms");
}
/**
* 通過另外一種for迴圈來遍歷LinkedList
*/
private static void iteratorThroughFor2(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時間
long start = System.currentTimeMillis();
for (Integer integ:list)
;
// 記錄結束時間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughFor2：" + interval+" ms");
}
/**
* 通過pollFirst()來遍歷LinkedList
*/
private static void iteratorThroughPollFirst(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時間
long start = System.currentTimeMillis();
while(list.pollFirst() != null)
;
// 記錄結束時間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughPollFirst：" + interval+" ms");
}
/**
* 通過pollLast()來遍歷LinkedList
*/
private static void iteratorThroughPollLast(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時間
long start = System.currentTimeMillis();
while(list.pollLast() != null)
;
// 記錄結束時間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughPollLast：" + interval+" ms");
}
/**
* 通過removeFirst()來遍歷LinkedList
*/
private static void iteratorThroughRemoveFirst(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時間
long start = System.currentTimeMillis();
try {
while(list.removeFirst() != null)
;
} catch (NoSuchElementException e) {
}
// 記錄結束時間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughRemoveFirst：" + interval+" ms");
}
/**
* 通過removeLast()來遍歷LinkedList
*/
private static void iteratorThroughRemoveLast(LinkedList<Integer> list) {
if (list == null)
return ;
// 記錄開始時間
long start = System.currentTimeMillis();
try {
while(list.removeLast() != null)
;
} catch (NoSuchElementException e) {
}
// 記錄結束時間
long end = System.currentTimeMillis();
long interval = end - start;
System.out.println("iteratorThroughRemoveLast：" + interval+" ms");
}
}
複製程式碼iteratorLinkedListThruIterator：8 ms
iteratorLinkedListThruForeach：3724 ms
iteratorThroughFor2：5 ms
iteratorThroughPollFirst：8 ms
iteratorThroughPollLast：6 ms
iteratorThroughRemoveFirst：2 ms
iteratorThroughRemoveLast：2 ms
由此可見，遍歷LinkedList時，使用removeFist()或removeLast()效率最高。但用它們遍歷時，會刪除原始資料；若單純只讀取，而不刪除，應該使用第3種遍歷方式。
無論如何，千萬不要通過隨機訪問去遍歷LinkedList！
第5部分 LinkedList示例
下面通過一個示例來學習如何使用LinkedList的常用API
import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
/*
* @desc LinkedList測試程式。
*
* @author skywang
* @email kuiwu-wang@163.com
*/
public class LinkedListTest {
public static void main(String[] args) {
// 測試LinkedList的API
testLinkedListAPIs() ;
// 將LinkedList當作 LIFO(後進先出)的堆疊
useLinkedListAsLIFO();
// 將LinkedList當作 FIFO(先進先出)的佇列
useLinkedListAsFIFO();
}
/*
* 測試LinkedList中部分API
*/
private static void testLinkedListAPIs() {
String val = null;
//LinkedList llist;
//llist.offer("10");
// 新建一個LinkedList
LinkedList llist = new LinkedList();
//---- 新增操作 ----
// 依次新增1,2,3
llist.add("1");
llist.add("2");
llist.add("3");
// 將“4”新增到第一個位置
llist.add(1, "4");
System.out.println("
Test "addFirst(), removeFirst(), getFirst()"");
// (01) 將“10”新增到第一個位置。 失敗的話，丟擲異常！
llist.addFirst("10");
System.out.println("llist:"+llist);
// (02) 將第一個元素刪除。 失敗的話，丟擲異常！
System.out.println("llist.removeFirst():"+llist.removeFirst());
System.out.println("llist:"+llist);
// (03) 獲取第一個元素。 失敗的話，丟擲異常！
System.out.println("llist.getFirst():"+llist.getFirst());
System.out.println("
Test "offerFirst(), pollFirst(), peekFirst()"");
// (01) 將“10”新增到第一個位置。 返回true。
llist.offerFirst("10");
System.out.println("llist:"+llist);
// (02) 將第一個元素刪除。 失敗的話，返回null。
System.out.println("llist.pollFirst():"+llist.pollFirst());
System.out.println("llist:"+llist);
// (03) 獲取第一個元素。 失敗的話，返回null。
System.out.println("llist.peekFirst():"+llist.peekFirst());
System.out.println("
Test "addLast(), removeLast(), getLast()"");
// (01) 將“20”新增到最後一個位置。 失敗的話，丟擲異常！
llist.addLast("20");
System.out.println("llist:"+llist);
// (02) 將最後一個元素刪除。 失敗的話，丟擲異常！
System.out.println("llist.removeLast():"+llist.removeLast());
System.out.println("llist:"+llist);
// (03) 獲取最後一個元素。 失敗的話，丟擲異常！
System.out.println("llist.getLast():"+llist.getLast());
System.out.println("
Test "offerLast(), pollLast(), peekLast()"");
// (01) 將“20”新增到第一個位置。 返回true。
llist.offerLast("20");
System.out.println("llist:"+llist);
// (02) 將第一個元素刪除。 失敗的話，返回null。
System.out.println("llist.pollLast():"+llist.pollLast());
System.out.println("llist:"+llist);
// (03) 獲取第一個元素。 失敗的話，返回null。
System.out.println("llist.peekLast():"+llist.peekLast());
// 將第3個元素設定300。不建議在LinkedList中使用此操作，因為效率低！
llist.set(2, "300");
// 獲取第3個元素。不建議在LinkedList中使用此操作，因為效率低！
System.out.println("
get(3):"+llist.get(2));
// ---- toArray(T[] a) ----
// 將LinkedList轉行為陣列
String[] arr = (String[])llist.toArray(new String[0]);
for (String str:arr)
System.out.println("str:"+str);
// 輸出大小
System.out.println("size:"+llist.size());
// 清空LinkedList
llist.clear();
// 判斷LinkedList是否為空
System.out.println("isEmpty():"+llist.isEmpty()+"
");
}
/**
* 將LinkedList當作 LIFO(後進先出)的堆疊
*/
private static void useLinkedListAsLIFO() {
System.out.println("
useLinkedListAsLIFO");
// 新建一個LinkedList
LinkedList stack = new LinkedList();
// 將1,2,3,4新增到堆疊中
stack.push("1");
stack.push("2");
stack.push("3");
stack.push("4");
// 列印“棧”
System.out.println("stack:"+stack);
// 刪除“棧頂元素”
System.out.println("stack.pop():"+stack.pop());
// 取出“棧頂元素”
System.out.println("stack.peek():"+stack.peek());
// 列印“棧”
System.out.println("stack:"+stack);
}
/**
* 將LinkedList當作 FIFO(先進先出)的佇列
*/
private static void useLinkedListAsFIFO() {
System.out.println("
useLinkedListAsFIFO");
// 新建一個LinkedList
LinkedList queue = new LinkedList();
// 將10,20,30,40新增到佇列。每次都是插入到末尾
queue.add("10");
queue.add("20");
queue.add("30");
queue.add("40");
// 列印“佇列”
System.out.println("queue:"+queue);
// 刪除(佇列的第一個元素)
System.out.println("queue.remove():"+queue.remove());
// 讀取(佇列的第一個元素)
System.out.println("queue.element():"+queue.element());
// 列印“佇列”
System.out.println("queue:"+queue);
}
}
複製程式碼執行結果：
Test “addFirst(), removeFirst(), getFirst()”
llist:[10, 1, 4, 2, 3]
llist.removeFirst():10
llist:[1, 4, 2, 3]
llist.getFirst():1
Test “offerFirst(), pollFirst(), peekFirst()”
llist:[10, 1, 4, 2, 3]
llist.pollFirst():10
llist:[1, 4, 2, 3]
llist.peekFirst():1
Test “addLast(), removeLast(), getLast()”
llist:[1, 4, 2, 3, 20]
llist.removeLast():20
llist:[1, 4, 2, 3]
llist.getLast():3
Test “offerLast(), pollLast(), peekLast()”
llist:[1, 4, 2, 3, 20]
llist.pollLast():20
llist:[1, 4, 2, 3]
llist.peekLast():3
get(3):300
str:1
str:4
str:300
str:3
size:4
isEmpty():true
useLinkedListAsLIFO
stack:[4, 3, 2, 1]
stack.pop():4
stack.peek():3
stack:[3, 2, 1]
useLinkedListAsFIFO
queue:[10, 20, 30, 40]
queue.remove():10
queue.element():20
queue:[20, 30, 40]
文章有不當之處，歡迎指正，你也可以關注我的微信公眾號：
好好學java，獲取優質學習資源。