Java linkedList詳細介紹及使用示例

①LinkedList簡單介紹

1. 是一個繼承於AbstractSequentialList的雙向鏈表。它可以被當成堆棧、隊列或雙端隊列進行操作。
2. 實現了List接口，能對它進行隊列操作。
3. 實現了Deque接口，能當作雙端隊列使用。
4. 實現了Cloneable接口，覆蓋了clone(),能克隆。
5. 實現了java.io.Serializable接口，這意味着LinkedList支持序列化，能通過序列化去傳輸。
6. 是非同步的

②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  [e-mail]
 */
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]