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  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]

 

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM