inkedList （佇列、棧實現還沒看（打算學會使用方法即可）、另外兩篇參考文章還沒看）
阿新 • • 發佈：2020-07-23
LinkedList是一個以雙向連結串列實現的List，它除了作為List使用，還可以作為佇列或者堆疊使用。
LinkedList介紹
LinkedList繼承關係
LinkedList簡介
LinkedList是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當做堆疊、佇列或雙端佇列進行使用。LinkedList實現List介面，能讓它進行佇列操作。LinkedList實現Deque介面，即能將LinkedList當做雙端佇列使用。LinkedList實現Cloneable，即覆蓋了函式clone()，能被克隆。LinkedList實現了java.io.Serializable介面，這意味著LinkedList支援序列化，能通過序列化去傳輸。LinkedList中的操作不是執行緒安全的。
LinkedList原始碼分析
AbstractSequentialList介紹
我們在看LinkedList之前先簡單介紹下其父類AbstractSequentialList。
AbstractSequentialList繼承自AbstractList，是List介面的簡化版實現。
AbstractSequentialList只支援按次序訪問（連結串列在記憶體中不是按順序存放的，而是通過指標連在一起，為了訪問某一元素，必須從鏈頭開始順著指標才能找到某一個元素。），不像AbstractList 可以隨機訪問。
想要實現一個支援次序訪問的List的話，只需要繼承這個類，並實現的指定的方法listIterator(int index)和size()。實現ListIterator的hasNext()、next()、hasPrevious()、previous()、previousIndex()就可以獲得一個不可修改的列表，如果你想讓它可修改還需實現remove()、set(E e)、add(E e)方法。
屬性LinkedList的主要屬性如下程式碼所示:
//連結串列節點的個數 transient int size = 0; //連結串列首節點 transient Node<E> first;//連結串列尾節點 transient Node<E> last;
//內部靜態類 private static class Node<E> { //當前節點元素值 E item; //下一個節點 Node<E> next; //上一個節點 Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }
建構函式
無參建構函式
如果不傳入引數，則使用預設構造方法建立LinkedList物件，如下：
public LinkedList() { }
此時建立的是一個空的連結串列。
帶Collection物件的建構函式
public LinkedList(Collection<? extends E> c) { this(); addAll(c); }
首先會呼叫無引數的構造方法，然後呼叫addAll方法將集合內元素全部加入到連結串列中，addAll方法我們後面會詳細的分析。
從上述的倆個構造方法可以看出LinkedList是一個無界連結串列，不存在容量不足的問題。
新增元素
LinkedList主要提供addFirst、addLast、add、addAll等方法來實現元素的新增。下面我們一一來看：
//在連結串列首部新增元素 public void addFirst(E e) { linkFirst(e); }
private void linkFirst(E e) { //將內部儲存的首節點點賦值給f final Node<E> f = first; //建立新節點，新節點的next節點是當前的首節點 final Node<E> newNode = new Node<>(null, e, f); //把新節點作為新的首節點 first = newNode; //判斷是否是第一個新增的元素 //如果是將新節點賦值給last //如果不是把原首節點的prev設定為新節點 if (f == null) last = newNode; else f.prev = newNode; //更新連結串列節點個數 size++; //將集合修改次數加1 modCount++; }
//在連結串列尾部新增元素 public void addLast(E e) { linkLast(e); }
void linkLast(E e) { //將內部儲存的尾節點賦值給l final Node<E> l = last; //建立新節點，新節點的prev節點是當前的尾節點 final Node<E> newNode = new Node<>(l, e, null); //把新節點作為新的尾節點 last = newNode; //判斷是否是第一個新增的元素 //如果是將新節點賦值給first //如果不是把原首節點的next設定為新節點 if (l == null) first = newNode; else l.next = newNode; //更新連結串列節點個數 size++; //將集合修改次數加1 modCount++; }
//該方法和addLast方差不多，因為是無界的，所以新增元素總是會成功 public boolean add(E e) { linkLast(e); return true; }
//該方法和上面add方法的區別是，該方法可以指定位置插入元素 public void add(int index, E element) { //判斷是否越界 checkPositionIndex(index); //如果index等於連結串列節點個數，就將元素新增到倆表尾部，否則呼叫linkBefore方法 if (index == size) linkLast(element); else linkBefore(element, node(index)); }
//獲取指定位置的節點 Node<E> node(int index) { //如果index小於size的一半，就從首節點開始遍歷，一直獲取x的下一個節點 //如果index大於或等於size的一半，就從尾節點開始遍歷，一直獲取x的上一個節點 if (index < (size >> 1)) { Node<E> x = first; for (int i = 0; i < index; i++) x = x.next; return x; } else { Node<E> x = last; for (int i = size - 1; i > index; i--) x = x.prev; return x; } }
//將元素插入到指定節點前 void linkBefore(E e, Node<E> succ) { // assert succ != null; //拿到succ的上一節點 final Node<E> pred = succ.prev; //建立新節點 final Node<E> newNode = new Node<>(pred, e, succ); //將新節點作為succ的上一節點 succ.prev = newNode; //判斷succ是否是首節點 //如果是將新節點作為新的首節點 //如果不是將新節點作為pred的下一節點 if (pred == null) first = newNode; else pred.next = newNode; //更新連結串列節點個數 size++; //將集合修改次數加1 modCount++; }
//將集合內的元素依次插入index位置後 public boolean addAll(int index, Collection<? extends E> c) { //判斷是否越界 checkPositionIndex(index); //將集合轉換為陣列 Object[] a = c.toArray(); int numNew = a.length; //判斷陣列長度是否為0，為0直接返回false if (numNew == 0) return false; //pred上一個節點，succ當前節點 Node<E> pred, succ; //判斷index位置是否等於連結串列元素個數 //如果等於succ賦值為null，pred賦值為當前連結串列尾節點last //如果不等於succ賦值為index位置的節點，pred賦值為succ的上一個節點 if (index == size) { succ = null; pred = last; } else { succ = node(index); pred = succ.prev; } //迴圈陣列 for (Object o : a) { @SuppressWarnings("unchecked") E e = (E) o; //建立新節點 Node<E> newNode = new Node<>(pred, e, null); //如果上一個節點為null，把新節點作為新的首節點，否則pred的下一個節點為新節點 if (pred == null) first = newNode; else pred.next = newNode; //把新節點賦值給上一個節點 pred = newNode; } //如果index位置的節點為null，把pred作業尾節點 //如果不為null，pred的下一節點為index位置的節點，succ的上一節點為pred if (succ == null) { last = pred; } else { pred.next = succ; succ.prev = pred; } //更新連結串列節點個數 size += numNew; //將集合修改次數加1 modCount++; //因為是無界的，所以新增元素總是會成功 return true; }
看到上面這麼多種方式新增元素，其實本質只是三種方式，在連結串列的首部、尾部、中間位置新增元素。如下圖所示：
在連結串列首尾新增元素很高效，在中間新增元素比較低效，首先要找到插入位置的節點，在修改前後節點的指標。
刪除元素
LinkedList提供了remove、removeFirst、removeLast等方法刪除元素。
public boolean remove(Object o) { //因為LinkedList允許存在null，所以需要進行null判斷 if (o == null) { //從首節點開始遍歷 for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) { //呼叫unlink方法刪除指定節點 unlink(x); return true; } } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; }
//刪除指定節點 E unlink(Node<E> x) { //獲取x節點的元素，以及它上一個節點，和下一個節點 final E element = x.item; final Node<E> next = x.next; final Node<E> prev = x.prev; //如果x的上一個節點為null，說明是首節點，將x的下一個節點設定為新的首節點 //否則將x的上一節點設定為next，將x的上一節點設為null if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } //如果x的下一節點為null，說明是尾節點，將x的上一節點設定新的尾節點 //否則將x的上一節點設定x的上一節點，將x的下一節點設為null if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } //將x節點的元素值設為null，等待垃圾收集器收集 x.item = null; //連結串列節點個數減1 size--; //將集合修改次數加1 modCount++; //返回刪除節點的元素值 return element; }
//刪除指定位置的節點，其實和上面的方法差不多 //通過node方法獲得指定位置的節點，再通過unlink方法刪除 public E remove(int index) { checkElementIndex(index); return unlink(node(index)); }
//刪除首節點 public E remove() { return removeFirst(); }
//刪除首節點 private E unlinkFirst(Node<E> f) { //首節點的元素值 final E element = f.item; //首節點的下一節點 final Node<E> next = f.next; //將首節點的元素值和下一節點設為null，等待垃圾收集器收集 f.item = null; f.next = null; // help GC //將next設定為新的首節點 first = next; //如果next為null，說明說明連結串列中只有一個節點，把last也設為null //否則把next的上一節點設為null if (next == null) last = null; else next.prev = null; //連結串列節點個數減1 size--; //將集合修改次數加1 modCount++; //返回刪除節點的元素值 return element; }
//刪除尾節點 public E removeLast() { final Node<E> l = last; //如果首節點為null，說明是空連結串列，丟擲異常 if (l == null) throw new NoSuchElementException(); return unlinkLast(l); }
private E unlinkLast(Node<E> l) { //尾節點的元素值 final E element = l.item; //尾節點的上一節點 final Node<E> prev = l.prev; //將尾節點的元素值和上一節點設為null，等待垃圾收集器收集 l.item = null; l.prev = null; // help GC //將prev設定新的尾節點 last = prev; //如果prev為null，說明說明連結串列中只有一個節點，把first也設為null //否則把prev的下一節點設為null if (prev == null) first = null; else prev.next = null; //連結串列節點個數減1 size--; //將集合修改次數加1 modCount++; //返回刪除節點的元素值 return element; }
刪除和新增一樣，其實本質只有三種方式，即刪除首部、尾部、中間節點。如下圖所示：
和新增一樣，首尾刪除很高效，刪除中間元素比較低效要先找到節點位置，再修改前後指標。
獲取元素
LinkedList提供了get、getFirst、getLast等方法獲取節點元素值。
//獲取指定位置的元素值 public E get(int index) { //判斷是否越界 checkElementIndex(index); //直接呼叫node方法獲取指定位置的節點，並反回其元素值 return node(index).item; }
//獲取連結串列首節點的元素值 public E getFirst() { final Node<E> f = first; //判斷是否是空連結串列，如果是丟擲異常，否則直接返回首節點的元素值 if (f == null) throw new NoSuchElementException(); return f.item; }
//獲取連結串列尾節點的元素值 public E getLast() { final Node<E> l = last; //判斷是否是空連結串列，如果是丟擲異常，否則直接返回尾節點的元素值 if (l == null) throw new NoSuchElementException(); return l.item; }
更新指定位置節點的元素值
public E set(int index, E element) { //判斷是否越界 checkElementIndex(index); //指定位置的節點 Node<E> x = node(index); E oldVal = x.item; //設定新值 x.item = element; //返回老值 return oldVal; }
關於佇列的操作
LinkedList可以作為FIFO(First In First Out)的佇列，也就是先進先出的佇列使用，以下是關於佇列的操作。
//獲取佇列的第一個元素，如果為null會返回null public E peek() { final Node<E> f = first; return (f == null) ? null : f.item; } //獲取佇列的第一個元素，如果為null會丟擲異常 public E element() { return getFirst(); } //獲取佇列的第一個元素，如果為null會返回null public E poll() { final Node<E> f = first; return (f == null) ? null : unlinkFirst(f); } //獲取佇列的第一個元素，如果為null會丟擲異常 public E remove() { return removeFirst(); } //將元素新增到佇列尾部 public boolean offer(E e) { return add(e); }
關於雙端佇列的操作
雙端列隊可以作為棧使用，棧的特性是LIFO(Last In First Out)，也就是後進先出。所以作為棧使用也很簡單，新增和刪除元素都只操作佇列的首節點即可
//將元素新增到首部 public boolean offerFirst(E e) { addFirst(e); return true; } //將元素新增到尾部 public boolean offerLast(E e) { addLast(e); return true; } //獲取首部的元素值 public E peekFirst() { final Node<E> f = first; return (f == null) ? null : f.item; } //獲取尾部的元素值 public E peekLast() { final Node<E> l = last; return (l == null) ? null : l.item; } //刪除首部，如果為null會返回null public E pollFirst() { final Node<E> f = first; return (f == null) ? null : unlinkFirst(f); } //刪除尾部，如果為null會返回null public E pollLast() { final Node<E> l = last; return (l == null) ? null : unlinkLast(l); } //將元素新增到首部 public void push(E e) { addFirst(e); } //刪除首部，如果為null會丟擲異常 public E pop() { return removeFirst(); } //刪除連結串列中元素值等於o的第一個節點，其實和remove方法是一樣的，因為內部還是呼叫的remove方法 public boolean removeFirstOccurrence(Object o) { return remove(o); } //刪除連結串列中元素值等於o的最後一個節點 public boolean removeLastOccurrence(Object o) { //因為LinkedList允許存在null，所以需要進行null判斷 if (o == null) { //和remove方法的區別它是從尾節點往前遍歷 for (Node<E> x = last; x != null; x = x.prev) { if (x.item == null) { //呼叫unlink方法刪除指定節點 unlink(x); return true; } } } else { for (Node<E> x = last; x != null; x = x.prev) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; }
其他方法
//判斷元素是否存在於連結串列中 public boolean contains(Object o) { return indexOf(o) != -1; } //從前往後查詢返回節點元素值等於o的位置，不存在返回-1 public int indexOf(Object o) { int index = 0; if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) return index; index++; } } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) return index; index++; } } return -1; } //該方法和上面indexOf方法相反，它是從後往前查詢返回節點元素值等於o的位置，不存在返回-1 public int lastIndexOf(Object o) { int index = size; if (o == null) { for (Node<E> x = last; x != null; x = x.prev) { index--; if (x.item == null) return index; } } else { for (Node<E> x = last; x != null; x = x.prev) { index--; if (o.equals(x.item)) return index; } } return -1; } //克隆函式，返回LinkedList的克隆物件 public Object clone() { LinkedList<E> clone = superClone(); // 將新建LinkedList置於最初狀態 clone.first = clone.last = null; clone.size = 0; clone.modCount = 0; // 將連結串列中所有節點的資料都新增到克隆物件中 for (Node<E> x = first; x != null; x = x.next) clone.add(x.item); return clone; } //返回LinkedList節點單元素值的Object陣列 public Object[] toArray() { Object[] result = new Object[size]; int i = 0; //將連結串列中所有節點的元素值新增到object陣列中 for (Node<E> x = first; x != null; x = x.next) result[i++] = x.item; return result; } // 返回LinkedList的模板陣列。所謂模板陣列，即可以將T設為任意的資料型別 public <T> T[] toArray(T[] a) { //如果a的長度小於LinkedList節點個數，說明a不能容納LinkedList的所有節點元素值 //則新建一個數組，陣列大小為LinkedList節點個數，並賦值給a if (a.length < size) a = (T[])java.lang.reflect.Array.newInstance( a.getClass().getComponentType(), size); int i = 0; Object[] result = a; // 將連結串列中所有節點的元素值都新增到陣列a中 for (Node<E> x = first; x != null; x = x.next) result[i++] = x.item; if (a.length > size) a[size] = null; return a; } //將LinkedList中的資料寫入到輸入流中，先寫容量，再寫資料 private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { // Write out any hidden serialization magic s.defaultWriteObject(); // Write out size s.writeInt(size); // Write out all elements in the proper order. for (Node<E> x = first; x != null; x = x.next) s.writeObject(x.item); } //從輸入流中讀取資料，一樣是先讀容量，再讀資料 private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in any hidden serialization magic s.defaultReadObject(); // Read in size int size = s.readInt(); //從輸入流中將元素值逐個新增到連結串列中 // Read in all elements in the proper order. for (int i = 0; i < size; i++) linkLast((E)s.readObject()); }
總結
- LinkedList自己實現了序列化和反序列化，因為它實現了writeObject和readObject方法。
- LinkedList是一個以雙向連結串列實現的List。
- LinkedList還是一個雙端佇列，具有佇列、雙端佇列、棧的特性。
- LinkedList在首部和尾部新增、刪除元素效率高效，在中間新增、刪除元素效率較低。
- LinkedList雖然實現了隨機訪問，但是效率低效，不建議使用。
- LinkedList是執行緒不安全的。
可參考：Java集合 LinkedList的原理及使用 LinkedList 基本示例及原始碼解析