①LinkedList簡單介紹
- 是一個繼承於AbstractSequentialList的雙向鏈表。它可以被當成堆棧、隊列或雙端隊列進行操作。
- 實現了List接口,能對它進行隊列操作。
- 實現了Deque接口,能當作雙端隊列使用。
- 實現了Cloneable接口,覆蓋了clone(),能克隆。
- 實現了java.io.Serializable接口,這意味着LinkedList支持序列化,能通過序列化去傳輸。
- 是非同步的
②LinkedList構造函數
// 默認構造函數
LinkedList()
// 創建一個LinkedList,保護Collection中的全部元素。
LinkedList(Collection<? extends E> collection)
③AbstractSequentialList簡介
介紹一下AbstractSequentialList。畢竟,LinkedList是AbstractSequentialList的子類。
1)AbstractSequentialList 實現了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)這些函數。這些接口都是隨機訪問List的,LinkedList是雙向鏈表;既然它繼承於AbstractSequentialList,就相當於已經實現了“get(int index)這些接口”。
2)我們若需要通過AbstractSequentialList自己實現一個列表,只需要擴展此類,並提供 listIterator() 和 size() 方法的實現即可。若要實現不可修改的列表,則需要實現列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法即可。 LinkedList是AbstractSequentialList的子類。
3)AbstractSequentialList實現了get(int index)、set(int indext, E element)、add(int index,E element)和remove(int index)這些函數。這些接口都是隨機訪問List的,LinkedList是雙向鏈表,既然它繼承了AbstractSequentialList,就相當於已經實現了這些接口。
4)若需要通過AbstractSequentialList自己實現一個列表,只需要擴展此類,並提供listIterator()和size()方法的實現即可。若要實現不可修改的列表,則需要實現列表迭代器的hasNext、next、hasPrevious、previous和index方法即可。
④LinkedList其他介紹
1)LinkedList包含兩個重要的成員: header和size
2)Header是雙向鏈表的表頭,它是雙向鏈表節點所對應的類Entry的實例。Entry中包含成員變量:previous,next,element。Previous是該節點的上一個節點,next是該節點的下一個節點,next是該節點的下一個節點,element是該節點所包含的值。
3)先對LinkedList的整體實現進行大致說明:
LinkedList實際上是通過雙向鏈表去實現的。既然是雙向鏈表,那么它的順序訪問會非常高效,而隨機訪問效率比較低。
既然LinkedList是通過雙向鏈表的,但是它也實現了List接口{也就是說,它實現了get(int location)、remove(int location)等“根據索引值來獲取、刪除節點的函數”}。
4)LinkedList是如何實現List的這些接口的,如何將“雙向鏈表和索引值聯系起來的”?
實際原理非常簡單,它就是通過一個計數索引值來實現的。例如,當我們調用get(int location)時,首先會比較“location”和“雙向鏈表長度的1/2”;若前者大,則從鏈表頭開始往后查找,直到location位置;否則,從鏈表末尾開始先前查 找,直到location位置。
⑤LinkedList其他介紹
(01) LinkedList 實際上是通過雙向鏈表去實現的。
它包含一個非常重要的內部類:Entry。Entry是雙向鏈表節點所對應的數據結構,它包括的屬性有:當前節點所包含的值,上一個節點,下一個節點。
(02) 從LinkedList的實現方式中可以發現,它不存在LinkedList容量不足的問題。
(03) LinkedList的克隆函數,即是將全部元素克隆到一個新的LinkedList對象中。
(04) LinkedList實現java.io.Serializable。當寫入到輸出流時,先寫入“容量”,再依次寫入“每一個節點保護的值”;當讀出輸入流時,先讀取“容量”,再依次讀取“每一個元素”。
(05) 由於LinkedList實現了Deque,而Deque接口定義了在雙端隊列兩端訪問元素的方法。提供插入、移除和檢查元素的方法。每種方法都存在兩種形式:一種形式在操作失敗時拋出異常,另一種形式返回一個特殊值(null 或 false,具體取決於操作)。
⑥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) {
}
測試這些遍歷方式效率的代碼如下
import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
/*
* @desc 測試LinkedList的幾種遍歷方式和效率
*
* @author skywang
*/
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!
⑦LinkedList示例
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("\nTest \"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("\nTest \"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("\nTest \"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("\nTest \"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("\nget(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()+"\n");
}
/**
* 將LinkedList當作 LIFO(后進先出)的堆棧
*/
private static void useLinkedListAsLIFO() {
System.out.println("\nuseLinkedListAsLIFO");
// 新建一個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("\nuseLinkedListAsFIFO");
// 新建一個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]