2. 程式人生 > >Java LinkedList的實現原理詳解

Java LinkedList的實現原理詳解

阿新 • • 發佈：2018-11-16

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow

也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

               

LinkedList是Java List型別的集合類的一種實現，此外，LinkedList還實現了Deque介面。本文基於Java1.8，對於LinkedList的實現原理做一下詳細講解。

（Java1.8原始碼：

http://docs.oracle.com/javase/8/docs/api/）

一、LinkedList實現原理總結


LinkedList的實現原理總結如下：

①資料儲存是基於雙向連結串列實現的。

②插入資料很快。先是在雙向連結串列中找到要插入節點的位置index，找到之後，再插入一個新節點。 雙向連結串列查詢index位置的節點時，有一個加速動作：若index < 雙向連結串列長度的1/2，則從前向後查詢; 否則，從後向前查詢。

③刪除資料很快。先是在雙向連結串列中找到要插入節點的位置index，找到之後，進行如下操作：node.previous.next = node.next;node.next.previous = node.previous;node = null 。查詢節點過程和插入一樣。

④獲取資料很慢，需要從Head節點進行查詢。

⑤遍歷資料很慢，每次獲取資料都需要從頭開始。


二、ArrayList的實現原理詳解


（轉自：http://tan4836128.iteye.com/blog/1717809）

1. LinkedList概述：

List 介面的連結列表實現。實現所有可選的列表操作，並且允許所有元素（包括 null）。除了實現 List 介面外，LinkedList 類還為在列表的開頭及結尾 get、remove 和 insert 元素提供了統一的命名方法。這些操作允許將連結列表用作堆疊、佇列或雙端佇列。

此類實現 Deque 介面，為 add、poll 提供先進先出佇列操作，以及其他堆疊和雙端佇列操作。

所有操作都是按照雙重連結列表的需要執行的。在列表中編索引的操作將從開頭或結尾遍歷列表（從靠近指定索引的一端）。

注意，此實現不是同步的。如果多個執行緒同時訪問一個連結列表，而其中至少一個執行緒從結構上修改了該列表，則它必須 保持外部同步。（結構修改指新增或刪除一個或多個元素的任何操作；僅設定元素的值不是結構修改。）這一般通過對自然封裝該列表的物件進行同步操作來完成。如果不存在這樣的物件，則應該使用 Collections.synchronizedList 方法來“包裝”該列表。最好在建立時完成這一操作，以防止對列表進行意外的不同步訪問，如下所示：

                    List list = Collections.synchronizedList(new LinkedList(...));

此類的 iterator 和 listIterator 方法返回的迭代器是快速失敗 的：在迭代器建立之後，如果從結構上對列表進行修改，除非通過迭代器自身的 remove 或 add 方法，其他任何時間任何方式的修改，迭代器都將丟擲 ConcurrentModificationException。因此，面對併發的修改，迭代器很快就會完全失敗，而不冒將來不確定的時間任意發生不確定行為的風險。

注意，迭代器的快速失敗行為不能得到保證，一般來說，存在不同步的併發修改時，不可能作出任何硬性保證。快速失敗迭代器盡最大努力丟擲 ConcurrentModificationException。因此，編寫依賴於此異常的程式的方式是錯誤的，正確做法是：迭代器的快速失敗行為應該僅用於檢測程式錯誤。

 

2. LinkedList的實現：

Java程式碼   收藏程式碼
  1. private transient Entry<E> header = new Entry<E>(null, null, null);   

 

 這個成員變數是LinkedList的關鍵，它在連結串列中沒有實際資料意義，是連結串列的標示（通俗一點就是連結串列的第一個無意義的元素），而且被修飾為transient，標示著他不會被序列化。header也可以當做佇列末尾的元素，因為是雙向列表，所以header.next末尾元素後邊的元素就成了隊首元素，header.previous就是隊尾元素了，看一下它的新增方法

 

Java程式碼   收藏程式碼
  1. public void addFirst(E paramE) {  
  2.     addBefore(paramE, this.header.next);//隊首  
  3. }  
  4. public void addLast(E paramE) {  
  5.     addBefore(paramE, this.header);//隊尾  
  6. }  

 以上兩個方法都利用addBefore方法將元素新增到指定物件之前，

 

 addFirst向隊頭加元素，將元素paramE新增到header.next-隊首元素之前；

 addLast向隊尾加元素，將元素paramE新增到header之前；

 

         再看一下addBefore(E e,Entry<E> entry)函式

 

Java程式碼   收藏程式碼
  1. /*** 
  2.  * 要新增的元素：paramE 
  3.  * 目標物件：paramEntry 
  4.  */  
  5. private Entry<E> addBefore(E paramE, Entry<E> paramEntry)  
  6. {  
  7.     //要新增的物件  
  8.     Entry localEntry = new Entry(paramE, paramEntry, paramEntry.previous);  
  9.     /*** 
  10.      * localEntry.previous = paramEntry.previous 
  11.      * 目標物件的前一元素的後一元素（localEntry.previous.next）設定為要新增的物件 
  12.      */  
  13.     localEntry.previous.next = localEntry;  
  14.     /*** 
  15.      * localEntry.next = paramEntry 
  16.      * 目標物件的前一元素（localEntry.next.previous）設定為要新增的物件 
  17.      */  
  18.     localEntry.next.previous = localEntry;  
  19.     this.size += 1;  
  20.     this.modCount += 1;  
  21.     return localEntry;  
  22. }  
 

連結串列的基本特性是插入速度快，遍歷速度慢，下面兩個方法可以反映這個特點

 

Java程式碼   收藏程式碼
  1. public int indexOf(Object paramObject) {  
  2.     int i = 0;  
  3.     Entry localEntry;  
  4.     /*** 
  5.      * 遍歷規則：從頭到尾，序列呈升序狀態 
  6.      */  
  7.     if (paramObject == null)  
  8.         for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {  
  9.             if (localEntry.element == null)  
  10.                 return i;  
  11.             i++;  
  12.         }  
  13.     else {  
  14.         for (localEntry = this.header.next; localEntry != this.header; localEntry = localEntry.next) {  
  15.             if (paramObject.equals(localEntry.element))  
  16.                 return i;  
  17.             i++;  
  18.         }  
  19.     }  
  20.     return -1;  
  21. }  
  22. public int lastIndexOf(Object paramObject) {  
  23.     int i = this.size;  
  24.     Entry localEntry;  
  25.     /*** 
  26.      * 遍歷規則：從尾到頭，序列呈降序狀態 
  27.      */  
  28.     if (paramObject == null) {  
  29.         for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {  
  30.             i--;  
  31.             if (localEntry.element == null)  
  32.                 return i;  
  33.             }  
  34.     }else {  
  35.         for (localEntry = this.header.previous; localEntry != this.header; localEntry = localEntry.previous) {  
  36.             i--;  
  37.             if (paramObject.equals(localEntry.element))  
  38.                 return i;  
  39.         }  
  40.     }  
  41.     return -1;  
  42. }  

 值得注意的是，連結串列插入資料速度快的說法是相對的，在資料量很小的時候，ArrayList的插入速度不僅不比LinkedList慢，而且還快很多（本文不作介紹，讀者可自行測試），只有當資料量達到一定量，這個特性才會體現出來，這需要開發者明確需求場景

LinkedList的方法entry(int index)類似ArrayList的get(int index)

 

Java程式碼   收藏程式碼
  1. /*** 
  2.  * 根據序號獲取Entry物件 
  3.  */  
  4. private Entry<E> entry(int paramInt) {  
  5.     if ((paramInt < 0) || (paramInt >= this.size)) {  
  6.         throw new IndexOutOfBoundsException("Index: " + paramInt + ", Size: " + this.size);  
  7.     }  
  8.     Entry localEntry = this.header;  
  9.     int i;  
  10.     /*** 
  11.      * 二分法：目標序號小於Size的1/2，則從頭到尾 
  12.      *             如果大於Size的1/2，則從尾到頭 
  13.      */  
  14.     if (paramInt < this.size >> 1) {  
  15.         for (i = 0; i <= paramInt; i++)  
  16.             localEntry = localEntry.next;  
  17.     } else {  
  18.         for (i = this.size; i > paramInt; i--)  
  19.             localEntry = localEntry.previous;  
  20.     }  
  21.     return localEntry;  
  22. }  

LinkedList還提供了降序迭代器，如下

 

Java程式碼   收藏程式碼
  1. public Iterator<E> descendingIterator()   {  
  2.         return new DescendingIterator(null);  
  3.     }  
 

關於降序迭代的具體實現可以看看原始碼，很簡單

LinkedList是針對連結串列操作的一個比較全的實現，對於頻繁的資料插入有較高效率，研究其具體實現可更有利於準確的使用它。該類的toArray、clone以及其他一些方法很值得參考。

 

3. LinkedList.Entry

LinkedList的內部類Entry是實現Deque介面的基本操作單元，其結構如下：

 

Java程式碼   收藏程式碼
  1. private static class Entry<E>  
  2. {  
  3.     E element;  
  4.     Entry<E> next;  
  5.     Entry<E> previous;  
  6.     /*** 
  7.      * 構造方法：目標物件paramE將被放置在paramEntry1之前，paramEntry2之後 
  8.      */  
  9.     Entry(E paramE, Entry<E> paramEntry1, Entry<E> paramEntry2)  
  10.     {  
  11.         this.element = paramE;  
  12.         this.next = paramEntry1;  
  13.         this.previous = paramEntry2;  
  14.     }  
  15. }  

4. 內部迭代器：ListItr

雖然上層父類AbstractList<E>已經實現了迭代器，但LinkedList的直接父類AbstractSequentialList<E>給子類重新定義個一個需要實現的迭代器的抽象方法，程式碼如下：

 

Java程式碼   收藏程式碼
  1. public abstract class AbstractSequentialList<E> extends AbstractList<E> {  
  2.     /*** 
  3.      * 返回子類實現的迭代器 
  4.      */  
  5.     public Iterator<E> iterator() {  
  6.         return listIterator();  
  7.     }  
  8.     public abstract ListIterator<E> listIterator(int paramInt);  
  9. }  

 

此處實現的迭代器內部機制跟AbstractList基本一致，可以看看原始碼

此類的迭代器的實現機制可以通過ListItr的remove方法來分析，同時也可分析Java對雙端佇列的處理辦法

 

Java程式碼   收藏程式碼
  1. /*** 
  2.  * 當前指標位置：this.next 
  3.  * 當前所操作的物件：this.lastReturned 
  4.  */  
  5. public void remove() {  
  6.     checkForComodification();  
  7.     LinkedList.Entry localEntry = this.lastReturned.next;  
  8.     try {  
  9.         LinkedList.this.remove(this.lastReturned);  
  10.     } catch (NoSuchElementException localNoSuchElementException) {  
  11.         throw new IllegalStateException();  
  12.     }  
  13.     /*** 
  14.      * 當連結串列的size為0，指標會指向this.header，其他方法（如set方法）將以此判斷當前操作物件的狀態 
  15.      */  
  16.     if (this.next == this.lastReturned)  
  17.         this.next = localEntry;  
  18.     else  
  19.         this.nextIndex -= 1;  
  20.     /*** 
  21.      * 呼叫LinkedList.this.remove(E)之後 
  22.      * 當前操作物件this.lastReturned指向的物件被設定為this.header（原物件為null） 
  23.      * 指標移動到this.lastReturned.next 
  24.      */  
  25.     this.lastReturned = LinkedList.this.header;  
  26.     //修改次數加1  
  27.     this.expectedModCount += 1;  
  28. }  

           

給我老師的人工智慧教程打call！http://blog.csdn.net/jiangjunshow

這裡寫圖片描述

相關推薦

Java LinkedList的實現原理詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Java HashSet的實現原理詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Java ArrayList的實現原理詳解

ArrayList是Java List型別的集合類中最常使用的，本文基於Java1.8，對於ArrayList的實現原理做一下詳細講解。 一、ArrayList實現原理總結 ArrayList的實現原理總結如下： ①資料儲存是基於陣列實現的，預設初始容量為10； ②

Java執行緒池實現原理詳解

原理概述 其實java執行緒池的實現原理很簡單，說白了就是一個執行緒集合workerSet和一個阻塞佇列workQueue。當用戶向執行緒池提交一個任務(也就是執行緒)時，執行緒池會先將任務放入workQueue中。workerSet中的執行緒會不斷的從w

Java 定時任務實現原理詳解

在jdk自帶的庫中,有兩種技術可以實現定時任務。一種是使用Timer,另外一個則是ScheduledThreadPoolExecutor。下面為大家分析一下這兩個技術的底層實現原理以及各自的優缺點。 一、Timer 1. Timer的使用 class MyTask exte

反射和多型實現原理詳解

Table of Contents 反射和多型 多型 多型的定義和用法 多型的實現原理 反射 反射的實現原理 反射的應用 反射的弊端 反射和多型 這兩種技術並無直接聯絡，之所以把它們放在一起說，是因為Java提供讓我們在執行時識別物件和類的資訊，主要有

Python Web開發中，WSGI協議的作用和實現原理詳解

首先理解下面三個概念： WSGI：全稱是Web Server Gateway Interface，WSGI不是伺服器，python模組，框架，API或者任何軟體，只是一種規範，描述web server如何與web application通訊的規範。 uwsgi：與WSGI一樣是一種協議，是uWSGI伺服器

HashMap底層實現原理詳解（轉載）

本文轉自：https://blog.csdn.net/caihaijiang/article/details/6280251 java中HashMap詳解 HashMap 和 HashSet 是 Java Collection Framework 的兩個重要成員，其中 HashMap 是

java泛型原理詳解

一、Java泛型的實現方法：型別擦除 前面已經說了，Java的泛型是偽泛型。為什麼說Java的泛型是偽泛型呢？因為，在編譯期間，所有的泛型資訊都會被擦除掉。正確理解泛型概念的首要前提是理解型別擦出（type erasure）。 Java中的泛型基本上都是在編譯器這個層次來實現的。在生成的Java

golang net/http包部分實現原理詳解

net/http包在編寫golang web應用中有很重要的作用，它主要提供了基於HTTP協議進行工作的client實現和server實現，可用於編寫HTTP服務端和客戶端。 其使用方法也跟其他面嚮物件語言很相似，我們可以先從它的一些基礎用法來感受一下： 以下是

幾種壓縮演算法實現原理詳解

gzip 、zlib以及圖形格式png，使用的壓縮演算法都是deflate演算法。從gzip的原始碼中，我們瞭解到了defalte演算法的原理和實現。我閱讀的gzip版本為 gzip-1.2.4。下面我們將要對deflate演算法做一個分析和說明。首先簡單介紹一下基本原理，

Java 輕量級鎖原理詳解(Lightweight Locking)

大家知道，Java的多執行緒安全是基於Lock機制實現的，而Lock的效能往往不如人意。原因是，monitorenter與monitorexit這兩個控制多執行緒同步的bytecode原語，是JVM依賴操作系統互斥(mutex)來實現的。互斥是一種會導致執行緒掛起，並在較短的

Spring Aop之Cglib實現原理詳解

Spring Aop實現對目標物件的代理，AOP的兩種實現方式：Jdk代理和Cglib代理。這兩種代理的區別在於，Jdk代理與目標類都會實現同一個介面，並且在代理類中會呼叫目標類中被代理的方法，呼叫者實際呼叫的則是代理類的方法，通過這種方式我們就可以在代理類中織入切面邏輯；Jdk代理存在的問題在於目標類被代

幾種主流貼圖壓縮演算法的實現原理詳解

ETC壓縮演算法採用將影象中的chromatic和luminance分開儲存的方式，而在解碼時使用luminance對chromatic進行調製進而重現原始影象資訊。   ETC也主要有兩種方法：ETC1和改進後的ETC2。 ETC1: 採用4x2的block進行分割（原始為4*2*24=192，壓

MVC之前的那點事兒系列（7）：WebActivator的實現原理詳解

文章內容 上篇文章，我們分析如何動態註冊HttpModule的實現，本篇我們來分析一下通過上篇程式碼原理實現的WebActivator類庫，WebActivator提供了3種功能，允許我們分別在HttpApplication初始化之前，之後以及ShutDown的時候分別執行指定的程式碼，示例如下： [

併發容器之ArrayBlockingQueue和LinkedBlockingQueue實現原理詳解

1. ArrayBlockingQueue簡介 在多執行緒程式設計過程中，為了業務解耦和架構設計，經常會使用併發容器用於儲存多執行緒間的共享資料，這樣不僅可以保證執行緒安全，還可以簡化各個執行緒操作。例如在“生產者-消費者”問題中，會使用阻塞佇列（Blocki

String類在記憶體中實現原理詳解

（1） ==  比較引用型別比較的是地址值是否相同 equals:比較引用型別預設也是比較地址值是否相同，而String類重寫了equals()方法，比較的是內容是否相同。 （2） 區分下面兩種語句在記憶體中的實現： <span style="font-size:14

XFS實現原理詳解

0 檔案系統      引用維基百科對檔案系統的定義：“計算機的檔案系統是一種儲存和組織計算機資料的方法，它使得對其訪問和查詢變得容易，檔案系統使用檔案和樹形目錄的抽象邏輯概念代替了硬碟和光碟等物理裝置使用資料塊的概念，使用者使用檔案系統來儲存資料不必關心資料實際儲存在硬碟

HashMap實現原理詳解

HashMap定義 HashMap實現了Map介面，一種將鍵對映到值得物件。 一個對映不能包含重複的鍵；每個鍵只能對映到一個值上。 HashMap的元素是無序的。要實現有序排列必須實現hashc

Hadoop詳解(二)——HDFS的命令，執行過程，Java介面，原理詳解。RPC機制

HDFS是Hadoop的一大核心，關於HDFS需要掌握的有：分散式系統與HDFS、HDFS的體系架構和基本概念、HDFS的shell操作、Java介面以及常用的API、Hadoop的RPC機制、遠端debugDistributed  File System資料量越來越多，在一