Java基礎之容器LinkedList
//元素個數transient int size = 0;//第一個元素指針transient Node<E> first;//最后一個元素指針transient Node<E> last;//Node節點的結構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; }}1.2.1 Node的結構
LinkedList結構
LinkedList特點
1.LinkedList是通過雙鏈表去實現的。
2.LinkedList不存在容量不足的問題，因為是鏈表。
3.LinkedList實現了Deque，而Deque接口定義了在雙端隊列兩端訪問元素的方法，所以LinkedList可以作為FIFO（先進先出）的隊列；LinkedList可以作為LIFO（后進先出）的棧
二、源碼分析2.1、添加元素//添加元素public boolean add(E e) { //默認調用，尾部添加元素的方法 linkLast(e); return true;}//尾部添加元素void linkLast(E e) { //記錄當前尾部元素 final Node<E> l = last; //創建一個新的Node節點 ，prev是當前的尾節點，next指向null final Node<E> newNode = new Node<>(l, e, null); //將last設置為新節點 last = newNode; //判斷當前尾部節點是否為null if (l == null)//當前尾部節點為null，就掛到頭結點上first = newNode; else//當前尾部節點不為null，就將新建的Node掛到當前last節點的next指針上l.next = newNode; //元素的個數+1 size++; //LinkedList修改記錄+1 modCount++;}
新增元素add()方法默認是尾部追加，核心就是將新建的Node節點追加到當前last節點的next指針上 ，偽代碼：
Node newNode=new Node();newNode.prev=last;last.next=newNode;last=newNode;last.next=null;
addFirst：首部追加
public void addFirst(E e) { linkFirst(e);}//頭部追加private void linkFirst(E e) { //記錄當前首部元素 final Node<E> f = first; //新建一個Node節點 final Node<E> newNode = new Node<>(null, e, f); //首部元素指向新建的節點 first = newNode; //判斷當前首部指針是否為null if (f == null)//當前首部指針為null,就把新建的節點掛到last指針上last = newNode; else//當前首部指針不為null,就把新建的節點掛到，當前first指針指向元素的prev指針上f.prev = newNode; //元素個數+1 size++; //LinkedList修改記錄+1 modCount++;}
首部追加的邏輯與尾部追加基本相同，偽代碼：
Node newNode=new Node();newNode.next=first;first.prev=newNode;first=newNode;first.prev=null;(也可以：newNode.prev=null)
指定位置添加元素：add(int index, E element)：
public void add(int index, E element) { //檢查要插入的位置是否合法 checkPositionIndex(index); //如要插入的位置在最后，直接調用linkLast() if (index == size)linkLast(element); else//如要插入的位置不在最后，就先查找再插入linkBefore(element, node(index));} //查找要插入元素的位置Node<E> node(int index) { // assert isElementIndex(index); //如果要插入的位置小于集合的一半，我就從頭開始找 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; final Node<E> pred = succ.prev; final Node<E> newNode = new Node<>(pred, e, succ); succ.prev = newNode; if (pred == null)first = newNode; elsepred.next = newNode; size++; modCount++;}
LinkedList是一個雙向鏈表，他只記錄了頭部和尾部位置，如果我們要指定位置插入，他會這么做：
1.先遍歷查找出要插入的元素位置，然后再插入；查找方式是根據 index < (size >> 1) 判斷結果，決定是從頭遍歷，還是從尾部遍歷，這種遍歷方式類似于二分查找(只在第一層循環二分)
2.新建一個Node節點，插入到查找出來的元素的前面
由此可知為何鏈表對隨機位置讀寫是不合適的；他的時間復雜度=O(n/2) ，如果n很大，我們一般就認為他的時間復雜度=O(n)
2.2、刪除元素//重寫List的remove()public boolean remove(Object o) { if (o == null) {//如果要刪除的元素null元素,從頭開始查找這個null元素for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) {unlink(x);return true; }} } else { //如果要刪除的元素不null元素,從頭開始查找這個非null元素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) { // assert x != null; //記錄改元素的值，實際作用就是做返回值 final E element = x.item; //記錄當前元素的下一個節點 final Node<E> next = x.next; //記錄當前元素的上一個節點 final Node<E> prev = x.prev; //判斷 x->prev 節點是否為null，為null就是刪除頭結點 if (prev == null) {first = next; } else {//將 x->prev節點的next指針指向x節點的下一個節點prev.next = next;//將 x->prev 指針，設置為null(斷開引用關系)x.prev = null; } //判斷 x->next 節點是否為null，為null就是刪尾部結點 if (next == null) {last = prev; } else {//將x->next節點的prev指針指向x->prevnext.prev = prev;//將 x->next指針，設置為null(斷開引用關系)x.next = null; } //將x的值設置為null x.item = null; //集合大小-1 size--; //集合的修改記錄-1 modCount++; return element;}
這里我們看到LinkedList重寫了List的remove方法，整個刪除邏輯也是先查找再刪除，時間復雜度O(n)，如果是刪除首部元素時間復雜度=O(1)，若要刪除尾部元素請使用removeLast( )
LinkedLis刪除首部元素：removeFirst() LinkedLis刪除尾部元素：removeLast() LinkedLis首部出隊：pollFirst( ) ，隊列的特點 LinkedLit尾部出隊：pollLast( )，隊列的特點2.3、迭代器Iterator迭代器只能是從頭往尾迭代，而LinkedList是雙向鏈表，他還可以從尾往頭部迭代，JAVA提供了一個新的迭代器接口：
public interface ListIterator<E> extends Iterator<E>{ //判斷是否存在下一個元素 boolean hasNext(); //獲取下一個元素 E next(); //判斷是否還有前一個元素 boolean hasPrevious(); //獲取前一個元素 E previous();}
LinkedList實現該接口：
private class ListItr implements ListIterator<E> { private Node<E> lastReturned;//上一次next() 或者 previous()的元素 private Node<E> next;//lastReturned->next 指向的元素 private int nextIndex;//下一個元素的位置 private int expectedModCount = modCount;}
LinkedList從前往后遍歷：
//是否存在下一個元素public boolean hasNext() { return nextIndex < size;}public E next() { //檢查集合的版本 checkForComodification(); if (!hasNext())throw new NoSuchElementException(); //lastReturned賦值上次next lastReturned = next; //next賦值為上次next->next next = next.next; //下一個元素的位置 nextIndex++; return lastReturned.item;}
LinkedList從后往前遍歷：
//判斷是否到頭了public boolean hasPrevious() { return nextIndex > 0;}//從尾部往頭部取數據public E previous() { checkForComodification(); if (!hasPrevious())throw new NoSuchElementException(); // next==null：第一次遍歷取尾節點(last)，或者上一次遍歷時把尾節點刪除掉了 // next!=null：已經發生過遍歷了，直接取前一個節點即可(next.prev) lastReturned = next = (next == null) ? last : next.prev; //遍歷的指針-1 nextIndex--; return lastReturned.item;}
迭代器刪除元素：
public void remove() { checkForComodification(); // lastReturned 是本次迭代需要刪除的值 // lastReturned==null則調用者沒有主動執行過 next() 或者 previos()，二直接調remove() // lastReturned!=null，是在上次執行 next() 或者 previos()方法時賦的值 if (lastReturned == null)throw new IllegalStateException(); //保存將當前要刪除節點的下一個節點(如果是從尾往頭遍歷，該值永遠是null) Node<E> lastNext = lastReturned.next; //刪除當前節點 unlink(lastReturned); // next == lastReturned：從尾到頭遞歸順序，并且是第一次迭代，并且要刪除最后一個元素的情況下， // previous() 方法里面設置了 lastReturned = next = last,所以 next 和 lastReturned會相等 if (next == lastReturned)next = lastNext; elsenextIndex--; lastReturned = null; expectedModCount++;}三、總結
LinkedList底層數據結構是雙向鏈表，所以他更適合順序操作，由于他繼承了Deque接口，同時他具有隊列的性質，非線程安全的集合
到此這篇關于Java基礎之容器LinkedList的文章就介紹到這了,更多相關Java容器LinkedList內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！
相關文章：
網公網安備