LinkedList 底層資料結構

• 是一個雙向連結串列

連結串列結構的優缺點:

1. 連結串列查詢慢，需要遍歷連結串列
2. 連結串列增刪快，每次只需要對連結串列中的一個結點新增或刪除

LinkedList繼承關係

• Serializable 標記性介面
• Cloneable 標記性介面
• Deque雙向佇列

LinkedList原始碼分析

構造方法

• 無參構造

  /**
       * 構造一個空列表。
       */
  public LinkedList() {
  }
  

• 帶單列集合的構造

  public LinkedList(Collection<? extends E> c) {
      this();
      addAll(c);
  }
   
  

  // 將集合插入到連結串列尾部，所以插入位置為size
  public boolean addAll(Collection<? extends E> c) {
      return addAll(size, c);
  }
  

  // 將集合從指定位置開始插入
  public boolean addAll(int index, Collection<? extends E> c) {
      // 檢查index位置是否合法，當index>=0並且index<=size連結串列中元素個數才合法，
      // 否則丟擲IndexOutOfBoundsException異常
      checkPositionIndex(index);
  
      // 將單列集合轉為Object[]陣列得到集合資料
      Object[] a = c.toArray();
      // 要新增的元素數量
      int numNew = a.length;
      if (numNew == 0)
          return false;
  
      Node<E> pred, succ;
      // 如果插入位置為尾部，前驅節點為last，後繼節點為null
      if (index == size) {
          succ = null;
          pred = last;
      } else {
          // 否則，呼叫node方法得到後繼節點，再得到前驅節點
          succ = node(index);
          pred = succ.prev;
      }
  	// 遍歷資料將資料插入
      for (Object o : a) {
          @SuppressWarnings("unchecked") E e = (E) o;
          // 初始化一個Node節點newNode，其中pre指向前一個節點pred，next指向null
          Node<E> newNode = new Node<>(pred, e, null);
          // 當插入位置為連結串列頭部時，讓first指向newNode節點
          if (pred == null)
              first = newNode;
          else
              // 否則，讓前一個節點pred的後繼節點指向newNode節點
              pred.next = newNode;
          // pred向前移動到新節點
          pred = newNode;
      }
  
      // 如果插入的位置在連結串列尾部，重置last指向pred
      if (succ == null) {
          last = pred;
      } else {
          // 否則，將插入的連結串列和之前的連結串列連線起來
          pred.next = succ;
          succ.prev = pred;
      }
  
      // 修改節點個數
      size += numNew;
      // 併發修改次數+1
      modCount++;
      return true;
  }
   
  

  private void checkPositionIndex(int index) {
      if (!isPositionIndex(index))
          throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  }
  

  private boolean isPositionIndex(int index) {
      return index >= 0 && index <= size;
  }
  

  Node<E> node(int index) {
      // 當下標位置小於元素數量的一半時，從linkedlist左邊開始向後遍歷
      if (index < (size >> 1)) {
          Node<E> x = first;
          for (int i = 0; i < index; i++)
              x = x.next;
          return x;
      } else {
          // 當下標位置大於元素數量的一半時，從linkedlist右邊開始向前遍歷
          Node<E> x = last;
          for (int i = size - 1; i > index; i--)
              x = x.prev;
          return x;
      }
  }
   
  

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

add原始碼分析

在連結串列尾部插入一個節點

public boolean add(E e) {
    // 在連結串列尾部插入一個節點
    linkLast(e);
    return true;
}

void linkLast(E e) {
    // 指向連結串列尾部
    final Node<E> l = last;
    // 建立一個新節點，前驅節點指向尾部 
    final Node<E> newNode = new Node<>(l, e, null);
    // 將last指向新節點
    last = newNode;
    // 如果連結串列為空，將first指向新節點
    if (l == null)
        first = newNode;
    else
        // 如果不為空，將原連結串列尾部指向新節點
        l.next = newNode;
    // 節點個數+1
    size++;
    // 併發修改次數+1
    modCount++;
}

在連結串列指定位置插入一個新節點

public void add(int index, E element) {
    // 呼叫checkPositionIndex檢查index位置是否合法，當index>=0並且index<=size節點數，合法；否則，丟擲indexOutOfBoundsException異常
    checkPositionIndex(index);

    // 新增到連結串列尾部
    if (index == size)
        linkLast(element);
    else
        // 新增到連結串列中間, 呼叫node方法得到index插入位置的節點
        linkBefore(element, node(index));
}

void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    // 先得到插入位置的前驅節點pred
    final Node<E> pred = succ.prev;
    // 新建一個節點，前驅節點指向pred，後繼節點指向插入位置的節點
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 修改插入位置節點的前驅節點指向新建的節點
    succ.prev = newNode;
    // 如果新節點是頭節點，讓first指向新節點
    if (pred == null)
        first = newNode;
    else
        // 如果不是，將pred的後繼節點指向新建節點
        pred.next = newNode;
    // 節點個數+1
    size++;
    // 併發修改次數+1
    modCount++;
}

在連結串列頭部插入一個節點

public void addFirst(E e) {
    linkFirst(e);
}

private void linkFirst(E e) {
    // 先得到first指向的頭節點
    final Node<E> f = first;
    // 建立一個新節點，前驅節點為null，後繼節點指向first
    final Node<E> newNode = new Node<>(null, e, f);
    // 讓first指向新節點
    first = newNode;
    // 如果是空連結串列，last也要指向新節點
    if (f == null)
        last = newNode;
    else
        // 如果不是，將頭節點的前驅節點指向新節點
        f.prev = newNode;
    // 節點個數+1
    size++;
    // 併發修改次數+1
    modCount++;
}

在連結串列尾部追加一個節點

public void addLast(E e) {
    linkLast(e);
}

void linkLast(E e) {
    // 先得到last指向的尾節點
    final Node<E> l = last;
    // 建立一個新節點，前驅節點指向last，後繼節點為null
    final Node<E> newNode = new Node<>(l, e, null);
    // 讓last指向新節點
    last = newNode;
    // 如果是空連結串列，first也要指向新節點
    if (l == null)
        first = newNode;
    else
        // 如果不是，將尾節點的後繼節點指向新節點
        l.next = newNode;
    // 節點個數+1
    size++;
    // 併發修改次數+1
    modCount++;
}

get原始碼解析

獲取指定位置的資料

public E get(int index) {
    //呼叫checkElementIndex檢查index位置是否合法，當indexindex >= 0 && index < size節點個數時合法，否則丟擲IndexOutOfBoundsException異常
    checkElementIndex(index);
    //呼叫node方法獲取index位置的節點，返回節點的元素
    return node(index).item;
}

private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}

獲取連結串列中的第一個元素

public E getFirst() {
    final Node<E> f = first;
    // 如果頭節點first為空，丟擲NoSuchElementException
    if (f == null)
        throw new NoSuchElementException();
    // 否則返回頭節點資料
    return f.item;
}

獲取連結串列中的最後一個元素

public E getLast() {
    // 如果尾節點last為空，丟擲NoSuchElementException
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    // 否則返回尾節點資料
    return l.item;
}

set原始碼分析

修改指定位置節點的元素

public E set(int index, E element) {
    // 呼叫checkElementIndex檢查index位置是否合法，當indexindex >= 0 && index < size節點個數時合法，否則丟擲IndexOutOfBoundsException異常
    checkElementIndex(index);
    // 獲取指定位置index的節點
    Node<E> x = node(index);
    // 記錄節點的舊值
    E oldVal = x.item;
    // 給節點賦新值
    x.item = element;
    // 返回舊值
    return oldVal;
}

indexOf原始碼解析

返回指定元素第一次出現的索引

public int indexOf(Object o) {
    // 初始化index=0，找不到就自增，找到就返回index
    int index = 0;
    // 如果指定元素為null，從頭節點開始遍歷連結串列，呼叫==進行比較
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        // 如果指定元素不為null，從頭節點開始遍歷連結串列，呼叫equals進行比較
        for (Node<E> x = first; x != null; x = x.next) {
            // 如果是x.item.equals(o)會有NULLPointException空指標異常
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    // 如果連結串列中沒有該元素，返回-1
    return -1;
}

返回指定元素最後一次出現的索引

public int lastIndexOf(Object o) {
    // 初始化index=size節點個數，找不到就自減，找到就返回index
    int index = size;
    // 如果指定元素為null，從尾節點開始遍歷連結串列，呼叫==進行比較
    if (o == null) {
        for (Node<E> x = last; x != null; x = x.prev) {
            // 如果是先判斷等於null再自減，在判斷等於null的時候出現了異常，就無法進行自減操作	
            index--;
            if (x.item == null)
                return index;
        }
    } else {
        // 如果指定元素不為null，從尾節點開始遍歷連結串列，呼叫equals進行比較
        for (Node<E> x = last; x != null; x = x.prev) {
            index--;
            // 如果是x.item.equals(o)會有NULLPointException空指標異常
            if (o.equals(x.item))
                return index;
        }
    }
    return -1;
}

remove原始碼解析

刪除連結串列的第一個元素

public E remove() {
    return removeFirst();
}

public E removeFirst() {
    // 如果頭節點為null，丟擲NoSuchElementException異常
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    // 先記錄頭節點的值element
    final E element = f.item;
    // 和頭節點的下一個節點next
    final Node<E> next = f.next;
    // 將頭節點的資料和後繼節點置為null，便於垃圾回收
    f.item = null;
    f.next = null; // help GC
    // 修改頭節點為第二個節點，讓first指向next
    first = next;
    // 如果next為空，說明當前連結串列只有一個節點，last也需要置為null
    if (next == null)
        last = null;
    else
        // 如果next不為空，將next的前驅節點置為null
        next.prev = null;
    // 節點個數+1
    size--;
    // 併發修改次數+1
    modCount++;
    // 返回記錄的element值
    return element;
}

刪除指定節點

public E remove(int index) {
    // 呼叫checkElementIndex檢查index位置是否合法，當indexindex >= 0 && index < size節點個數時合法，否則丟擲IndexOutOfBoundsException異常
    checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node<E> x) {
    // assert x != null;
    // 先記錄刪除位置節點的資料element，前驅節點prev和後繼節點next
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    // 如果刪除的節點是頭節點，first要指向刪除節點的後繼節點next
    if (prev == null) {
        first = next;
    } else {
        // 如果不是頭節點，則讓刪除節點的前驅節點指向後繼節點
        prev.next = next;
        // 刪除節點的前驅節點置為null，方便垃圾回收
        x.prev = null;
    }

    // 如果刪除的節點是尾節點，last要指向刪除節點的前驅節點prev
    if (next == null) {
        last = prev;
    } else {
        // 如果不是尾節點，則讓刪除節點的後繼節點指向前驅節點
        next.prev = prev;
        // 刪除節點的後繼節點置為null，方便垃圾回收
        x.next = null;
    }

    // 刪除節點元素也置為null
    x.item = null;
    // 節點個數減1
    size--;
    // 併發修改次數+1
    modCount++;
    // 返回刪除節點的值
    return element;
}

刪除指定元素

public boolean remove(Object o) {
    // 如果刪除元素是null，則從頭節點開始遍歷連結串列，呼叫==進行比較，再呼叫unlink方法刪除，返回true
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        // 如果刪除元素不是null，則從頭節點開始遍歷連結串列，呼叫equals進行比較，再呼叫unlink方法刪除，返回true
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    // 如果沒有刪除元素，返回false
    return false;
}

iterator原始碼分析

public Iterator<E> iterator() {
    return listIterator();
}

public ListIterator<E> listIterator() {
    return listIterator(0);
}

public ListIterator<E> listIterator(final int index) {
    // 檢查index
    rangeCheckForAdd(index);

    return new ListItr(index);
}

private void rangeCheckForAdd(int index) {
    if (index < 0 || index > size())
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        cursor = index;
    }

private class Itr implements Iterator<E> {
        /**
         * 後續呼叫next返回的元素索引。
         */
        int cursor = 0;

        /**
         * 最近一次呼叫next或返回的元素的索引
         * 以前。 如果此元素被呼叫刪除，則重置為-1
         * 去除。
         */
        int lastRet = -1;

        /**
         * 檢測併發修改
         */
        int expectedModCount = modCount;

        public boolean hasNext() {
            // 如果遊標cursor不等於連結串列節點的個數，說明還有元素
            return cursor != size();
        }

        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                // 獲取當前遊標的值
                E next = get(i);
                lastRet = i;
                // 遊標向下移
                cursor = i + 1;
                // 返回當前遊標的值
                return next;
            } catch (IndexOutOfBoundsException e) {
                // 判斷併發修改次數和預期修改次數是否相同，不相同丟擲ConcurrentModificationException併發修改異常
                checkForComodification();
                throw new NoSuchElementException();
            }
        }
}