LinkedList工做原理
1.學習LinkedList的必要性
在ArrayList工做原理中，咱們瞭解到ArrayList和LinkedList是List接口的兩個重要實現。而且ArrayList是一個動態數組的實現。所以ArrayList在隊列中插入和刪除元素方面的性能有很大的缺陷（這是由於插入和刪除元素時要確保ArrayList容量，消耗性能）。爲了實現隊列元素的快速插入和刪除，咱們來學習下LinkedList。java
2.LinkedList簡介
2.1 LinkedList定義
LinkedList是List接口的鏈表實現，是一個繼承於AbstractSequentialList的雙向鏈表。LinkedList類除了實現List接口外，還實現了Deque接口，爲add、poll提供先進先出的隊列操做，以及其餘堆棧和雙端隊列操做。LinkedList和ArrayList同樣都是非同步的。
2.2 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 {}
2.2 LinkedList與Collection的關係圖數據結構
LinkedList的本質是雙向鏈表。函數
- LinkedList繼承於AbstractSequentialList，而且實現了Dequeue接口。
- LinkedList包含兩個重要的成員：header 和 size。
- header是雙向鏈表的表頭，它是雙向鏈表節點所對應的類Entry的實例。Entry中包含成員變量： previous, next, element。其中，previous是該節點的上一個節點，next是該節點的下一個節點，element是該節點所包含的值。
- size是雙向鏈表中節點的個數
3. AbstractSequentialList介紹
在研究LinkedList源碼以前，咱們有必要先看一下AbstractSequentialList是什麼東西，由於畢竟LinkedList是繼承於AbstractSequentialList的。瞭解AbstractSequentialList抽象類就好。性能
public abstract class AbstractSequentialList<E> extends AbstractList<E>
此類是對AbstractList類的擴展，提供了 List 接口的骨幹實現，從而最大限度地減小了實現受「連續訪問」數據存儲（如連接列表）支持的此接口所需的工做。對於隨機訪問數據（如數組），應該優先使用 AbstractList，而不是先使用此類。
AbstractSequentialList實現了get(int index)、set(int index,E element)、add(int index,E element)和remove(int index)這些函數。這些接口都是隨機訪問List的，LinkedList是雙向鏈表；既然它繼承於AbstractSequentialList，就至關於已經實現了這些接口。
咱們要實現一個列表，只須要擴展此類，並提供 listIterator 和 size 方法的實現便可。對於不可修改的列表，咱們只須要實現列表迭代器的 hasNext、next、hasPrevious、previous 和 index 方法便可。
--- （摘自JDK1.7 API）
4.LinkedList源碼解析（JDK 1.7）
LinkedList總體說明：學習
- LinkedList其實是經過雙向鏈表去實現的。因此它的順序訪問效率比較高，隨機訪問效率低
- LinkedList實現了List接口，它實現了get(int index),remove(int index)等根據索引值來獲取、刪除節點的函數。
- JDK1.8中隊LinkedList作了較大的改動，利用內部類Node來代替了header，具體好處還未研究，有興趣的同窗能夠比較一下兩者之間的差異
LinkedList的源碼（帶中文翻譯）this
package java.util;
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
// 鏈表的表頭，表頭不包含任何數據。Entry是個鏈表類數據結構。
private transient Entry<E> header = new Entry<E>(null, null, null);
// LinkedList中元素個數
private transient int size = 0;
// 默認構造函數：建立一個空的鏈表
public LinkedList() {
header.next = header.previous = header;
}
// 包含「集合」的構造函數:建立一個包含「集合」的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
// 獲取LinkedList的第一個元素
public E getFirst() {
if (size==0)
throw new NoSuchElementException();
// 鏈表的表頭header中不包含數據。
// 這裏返回header所指下一個節點所包含的數據。
return header.next.element;
}
// 獲取LinkedList的最後一個元素
public E getLast() {
if (size==0)
throw new NoSuchElementException();
// 因爲LinkedList是雙向鏈表；而表頭header不包含數據。
// 於是，這裏返回表頭header的前一個節點所包含的數據。
return header.previous.element;
}
// 刪除LinkedList的第一個元素
public E removeFirst() {
return remove(header.next);
}
// 刪除LinkedList的最後一個元素
public E removeLast() {
return remove(header.previous);
}
// 將元素添加到LinkedList的起始位置
public void addFirst(E e) {
addBefore(e, header.next);
}
// 將元素添加到LinkedList的結束位置
public void addLast(E e) {
addBefore(e, header);
}
// 判斷LinkedList是否包含元素(o)
public boolean contains(Object o) {
return indexOf(o) != -1;
}
// 返回LinkedList的大小
public int size() {
return size;
}
// 將元素(E)添加到LinkedList中
public boolean add(E e) {
// 將節點(節點數據是e)添加到表頭(header)以前。
// 即，將節點添加到雙向鏈表的末端。
addBefore(e, header);
return true;
}
// 從LinkedList中刪除元素(o)
// 從鏈表開始查找，如存在元素(o)則刪除該元素並返回true；
// 不然，返回false。
public boolean remove(Object o) {
if (o==null) {
// 若o爲null的刪除狀況
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
// 若o不爲null的刪除狀況
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
// 將「集合(c)」添加到LinkedList中。
// 實際上，是從雙向鏈表的末尾開始，將「集合(c)」添加到雙向鏈表中。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
// 從雙向鏈表的index開始，將「集合(c)」添加到雙向鏈表中。
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Object[] a = c.toArray();
// 獲取集合的長度
int numNew = a.length;
if (numNew==0)
return false;
modCount++;
// 設置「當前要插入節點的後一個節點」
Entry<E> successor = (index==size ? header : entry(index));
// 設置「當前要插入節點的前一個節點」
Entry<E> predecessor = successor.previous;
// 將集合(c)所有插入雙向鏈表中
for (int i=0; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;
// 調整LinkedList的實際大小
size += numNew;
return true;
}
// 清空雙向鏈表
public void clear() {
Entry<E> e = header.next;
// 從表頭開始，逐個向後遍歷；對遍歷到的節點執行一下操做：
// (01) 設置前一個節點爲null
// (02) 設置當前節點的內容爲null
// (03) 設置後一個節點爲「新的當前節點」
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
header.next = header.previous = header;
// 設置大小爲0
size = 0;
modCount++;
}
// 返回LinkedList指定位置的元素
public E get(int index) {
return entry(index).element;
}
// 設置index位置對應的節點的值爲element
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
// 在index前添加節點，且節點的值爲element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
// 刪除index位置的節點
public E remove(int index) {
return remove(entry(index));
}
// 獲取雙向鏈表中指定位置的節點
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
// 獲取index處的節點。
// 若index < 雙向鏈表長度的1/2,則從前前後查找;
// 不然，從後向前查找。
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
// 從前向後查找，返回「值爲對象(o)的節點對應的索引」
// 不存在就返回-1
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element==null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
}
// 從後向前查找，返回「值爲對象(o)的節點對應的索引」
// 不存在就返回-1
public int lastIndexOf(Object o) {
int index = size;
if (o==null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element==null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
}
// 返回第一個節點
// 若LinkedList的大小爲0,則返回null
public E peek() {
if (size==0)
return null;
return getFirst();
}
// 返回第一個節點
// 若LinkedList的大小爲0,則拋出異常
public E element() {
return getFirst();
}
// 刪除並返回第一個節點
// 若LinkedList的大小爲0,則返回null
public E poll() {
if (size==0)
return null;
return removeFirst();
}
// 將e添加雙向鏈表末尾
public boolean offer(E e) {
return add(e);
}
// 將e添加雙向鏈表開頭
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
// 將e添加雙向鏈表末尾
public boolean offerLast(E e) {
addLast(e);
return true;
}
// 返回第一個節點
// 若LinkedList的大小爲0,則返回null
public E peekFirst() {
if (size==0)
return null;
return getFirst();
}
// 返回最後一個節點
// 若LinkedList的大小爲0,則返回null
public E peekLast() {
if (size==0)
return null;
return getLast();
}
// 刪除並返回第一個節點
// 若LinkedList的大小爲0,則返回null
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
}
// 刪除並返回最後一個節點
// 若LinkedList的大小爲0,則返回null
public E pollLast() {
if (size==0)
return null;
return removeLast();
}
// 將e插入到雙向鏈表開頭
public void push(E e) {
addFirst(e);
}
// 刪除並返回第一個節點
public E pop() {
return removeFirst();
}
// 從LinkedList開始向後查找，刪除第一個值爲元素(o)的節點
// 從鏈表開始查找，如存在節點的值爲元素(o)的節點，則刪除該節點
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
// 從LinkedList末尾向前查找，刪除第一個值爲元素(o)的節點
// 從鏈表開始查找，如存在節點的值爲元素(o)的節點，則刪除該節點
public boolean removeLastOccurrence(Object o) {
if (o==null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
// 返回「index到末尾的所有節點」對應的ListIterator對象(List迭代器)
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}
// List迭代器
private class ListItr implements ListIterator<E> {
// 上一次返回的節點
private Entry<E> lastReturned = header;
// 下一個節點
private Entry<E> next;
// 下一個節點對應的索引值
private int nextIndex;
// 指望的改變計數。用來實現fail-fast機制。
private int expectedModCount = modCount;
// 構造函數。
// 從index位置開始進行迭代
ListItr(int index) {
// index的有效性處理
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
// 若 「index 小於 ‘雙向鏈表長度的一半’」，則從第一個元素開始日後查找；
// 不然，從最後一個元素往前查找。
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}
// 是否存在下一個元素
public boolean hasNext() {
// 經過元素索引是否等於「雙向鏈表大小」來判斷是否達到最後。
return nextIndex != size;
}
// 獲取下一個元素
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();
lastReturned = next;
// next指向鏈表的下一個元素
next = next.next;
nextIndex++;
return lastReturned.element;
}
// 是否存在上一個元素
public boolean hasPrevious() {
// 經過元素索引是否等於0，來判斷是否達到開頭。
return nextIndex != 0;
}
// 獲取上一個元素
public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException();
// next指向鏈表的上一個元素
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
// 獲取下一個元素的索引
public int nextIndex() {
return nextIndex;
}
// 獲取上一個元素的索引
public int previousIndex() {
return nextIndex-1;
}
// 刪除當前元素。
// 刪除雙向鏈表中的當前節點
public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next==lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = header;
expectedModCount++;
}
// 設置當前節點爲e
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
// 將e添加到當前節點的前面
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 判斷 「modCount和expectedModCount是否相等」，依次來實現fail-fast機制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
// 雙向鏈表的節點所對應的數據結構。
// 包含3部分：上一節點，下一節點，當前節點值。
private static class Entry<E> {
// 當前節點所包含的值
E element;
// 下一個節點
Entry<E> next;
// 上一個節點
Entry<E> previous;
/**
* 鏈表節點的構造函數。
* 參數說明：
* element —— 節點所包含的數據
* next —— 下一個節點
* previous —— 上一個節點
*/
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
// 將節點(節點數據是e)添加到entry節點以前。
private Entry<E> addBefore(E e, Entry<E> entry) {
// 新建節點newEntry，將newEntry插入到節點e以前；而且設置newEntry的數據是e
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
// 修改LinkedList大小
size++;
// 修改LinkedList的修改統計數：用來實現fail-fast機制。
modCount++;
return newEntry;
}
// 將節點從鏈表中刪除
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}
// 反向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
// 反向迭代器實現類。
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
// 反向迭代器是否下一個元素。
// 其實是判斷雙向鏈表的當前節點是否達到開頭
public boolean hasNext() {
return itr.hasPrevious();
}
// 反向迭代器獲取下一個元素。
// 其實是獲取雙向鏈表的前一個節點
public E next() {
return itr.previous();
}
// 刪除當前節點
public void remove() {
itr.remove();
}
}
// 返回LinkedList的Object[]數組
public Object[] toArray() {
// 新建Object[]數組
Object[] result = new Object[size];
int i = 0;
// 將鏈表中全部節點的數據都添加到Object[]數組中
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}
// 返回LinkedList的模板數組。所謂模板數組，便可以將T設爲任意的數據類型
public <T> T[] toArray(T[] a) {
// 若數組a的大小 < LinkedList的元素個數(意味着數組a不能容納LinkedList中所有元素)
// 則新建一個T[]數組，T[]的大小爲LinkedList大小，並將該T[]賦值給a。
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
// 將鏈表中全部節點的數據都添加到數組a中
int i = 0;
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
if (a.length > size)
a[size] = null;
return a;
}
// 克隆函數。返回LinkedList的克隆對象。
public Object clone() {
LinkedList<E> clone = null;
// 克隆一個LinkedList克隆對象
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// 新建LinkedList表頭節點
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// 將鏈表中全部節點的數據都添加到克隆對象中
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
// java.io.Serializable的寫入函數
// 將LinkedList的「容量，全部的元素值」都寫入到輸出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// 寫入「容量」
s.writeInt(size);
// 將鏈表中全部節點的數據都寫入到輸出流中
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}
// java.io.Serializable的讀取函數：根據寫入方式反向讀出
// 先將LinkedList的「容量」讀出，而後將「全部的元素值」讀出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// 從輸入流中讀取「容量」
int size = s.readInt();
// 新建鏈表表頭節點
header = new Entry<E>(null, null, null);
header.next = header.previous = header;
// 從輸入流中將「全部的元素值」並逐個添加到鏈表中
for (int i=0; i<size; i++)
addBefore((E)s.readObject(), header);
}
}
源碼總結：spa
- LinkedList包含重要的內部類Entry。Entry是雙向鏈表節點對應的數據結構，它包括的屬性有：當前節點包含的值，上一個節點和下一個節點
- 從LinkedList的實現方式中能夠發現，它不存在容量不足問題，實際上LinkedList的存儲方式是鬆散結構
- LinkedList的克隆函數，將所有元素克隆到一個新的LinkedList對象中
- LinkedList實現了java.io.Serializable接口，可實現序列化
- LinkedList實現了Deque，而Deque接口定義了在雙端隊列兩端訪問元素的方法。提供插入、刪除和檢查元素的方法。每種方法都存在兩種形式：一種形式在操做失敗時拋出異常，另外一種形式返回特殊值null或false。
- LinkedList能夠做爲FIFO（先進先出）的隊列。
- LinkedList能夠做爲LIFO（後進先出）的棧。
5. LinkedList重要方法
看到有一篇博客寫的不錯，就引用過來了.net
相關文章
- 1. JDK8中LinkedList的工做原理剖析
- 2. LinkedList實現原理
- 3. LinkedList底層原理
- 4. ArrayList和LinkedList原理
- 5. LinkedList原理源碼分析
- 6. LinkedList 的實現原理
- 7. tomcat 工做原理
- 8. Hibernate工做原理
- 9. ThreadLocal 工做原理。
- 10. hashmap 工做原理
- 更多相關文章...
- • MyBatis的工作原理 - MyBatis教程
- • BASE原理與最終一致性 - NoSQL教程
- • ☆技術問答集錦（13）Java Instrument原理
- • Java Agent入門實戰（三）-JVM Attach原理與使用
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. JDK8中LinkedList的工做原理剖析
- 2. LinkedList實現原理
- 3. LinkedList底層原理
- 4. ArrayList和LinkedList原理
- 5. LinkedList原理源碼分析
- 6. LinkedList 的實現原理
- 7. tomcat 工做原理
- 8. Hibernate工做原理
- 9. ThreadLocal 工做原理。
- 10. hashmap 工做原理