java之LinkedList詳細介紹

本文轉載自查看原文 2018-10-29 20:07 1141 Java

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源碼解析

總結：
(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) {
}

測試這些遍歷方式效率的代碼如下：

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");
    }

}

View Code

由此可見，遍歷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("\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);
    }
}

View Code

本文來自http://www.cnblogs.com/skywang12345/p/3308807.html

免責聲明！

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

猜您在找 Java linkedList詳細介紹及使用示例 Java 集合系列05之 LinkedList詳細介紹(源碼解析)和使用示例 Java Vector ArrayList LinkedList介紹及區別 Java LinkedList Java TreeSet詳細介紹 java之Stack詳細介紹 java之Stack詳細介紹 java之ArrayList詳細介紹 java之vector詳細介紹 java中的各種鎖詳細介紹