LinkedList源碼解析（一）

基本屬性

transient int size = 0;//存儲數據量

    /**
     * Pointer to first node.
     */
    transient Node<E> first;//指向第一個節點的指針

    /**
     * Pointer to last node.
     */
    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(Collection<? extends E> c)構造方法

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

addAll(Collection<? extends E> c)將指定集合中的全部元素追加到末尾

public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

addAll(int index, Collection<? extends E> c)將指定集合中的全部元素，插入到指定索引處

public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);//下標在範圍內

        Object[] a = c.toArray();//轉化爲對象數組
        int numNew = a.length;
        if (numNew == 0)
            return false;//長度爲0直接返回false

        Node<E> pred, succ;
        if (index == size) {//若是是尾插入
            succ = null;//下一個節點：設置成null
            pred = last;//上一個節點：設置成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);//構造方法（前一個節點，數據，下一個節點）
            if (pred == null)//若是pre爲空說明集合沒有數據
                first = newNode;//那麼第一個節點指針指向newNode
            else
                pred.next = newNode;//前一個節點（上一次循環的newNode）的next設置爲newNode
                
            pred = newNode;//把pre設置成newNode供下一次循環使用
        }

        if (succ == null) {//若是是尾插入
            last = pred;//把指向最後一個節點的指針設置成pred，即設置成，最後一個newNode
        } else {//若是不是尾插入
            pred.next = succ;//newNode的next變成suc
            succ.prev = pred;//next的pre變成newNode
        }

        size += numNew;//修改存儲長度
        modCount++;
        return true;
    }

node(int index)返回指定元素索引處的（非null）節點

Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {//小於一半
            Node<E> x = first;
            for (int i = 0; i < index; i++)//從0日後循環到index
                x = x.next;
            return x;
        } else {//大於一半
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)//從size往前循環到index
                x = x.prev;
            return x;
        }
    }

linkFirst(E e)把e放置到鏈表開頭

private void linkFirst(E e) {
        final Node<E> f = first;//獲取第一個節點
        final Node<E> newNode = new Node<>(null, e, f);//建立一個新的節點，並設置下一個節點爲原來的第一個節點
        first = newNode;//第一個節點設置成newNode 
        if (f == null)//本來第一個節點爲空，即鏈表是空的
            last = newNode;//設置最後一個節點設置成newNode
        else
            f.prev = newNode;//不然本來第一個節點的上一個節點設置成newNode
        size++;
        modCount++;
    }

linkLast(E e)把e放在鏈表末尾

void linkLast(E e) {
        final Node<E> l = last;//獲取最後的節點
        final Node<E> newNode = new Node<>(l, e, null);//建立一個新的節點並設置上一個節點爲原來的最後一個節點
        last = newNode;//最後一個節點設置成newNode
        if (l == null)//若是本來最後節點爲空的，即鏈表是空的
            first = newNode;//設置第一個節點爲newNode
            第一個節點爲
        else
            l.next = newNode;//不然原來最後一個節點的下一個節點變成newNode
        size++;
        modCount++;
    }

linkBefore(E e, Node<E> succ)在節點succ前插入e

void linkBefore(E e, Node<E> succ) {
        // assert succ != null;  斷言succ不是空的
        final Node<E> pred = succ.prev;//獲取succ的上一個節點
        final Node<E> newNode = new Node<>(pred, e, succ);//新建一個節點，設置上一個節點爲pred，下一個節點爲succ
        succ.prev = newNode;//succ的上一個節點設置爲newNode
        if (pred == null)//若是succ是第一個節點
            first = newNode;//第一個節點指針指向newNode
        else
            pred.next = newNode;//不然succ上一個節點的next設置成newNode
        size++;//數據量加1
        modCount++;
    }

unlinkFirst(Node<E> f)取消第一個節點

private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;斷言f是首節點，而且f不是空的
        final E element = f.item;//獲取第一個節點的數據
        final Node<E> next = f.next;//獲取第一個節點的next
        f.item = null;//第一個節點數據置空
        f.next = null; //第一個節點的next置空，取消無效的引用幫助gc
        first = next;//第一個節點的指針指向next
        if (next == null)//若是是惟一的節點
            last = null;//最後一個節點的指針也置空
        else
            next.prev = null;//不然下一個節點的prev置空，（因爲成爲新的第一個節點，第一個節點沒有pre）
        size--;//數據量減1
        modCount++;
        return element;//返回取消的數據
    }

unlinkLast(Node<E> l)取消最後一個節點

private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;斷言l是最後一個節點，而且l不是空的
        final E element = l.item;//獲取最後一個節點的數據
        final Node<E> prev = l.prev;//獲取最後一個節點的prev
        l.item = null;//最後一個節點的數據置空
        l.prev = null; //最後一個節點的pre數據置空，取消無效的引用幫助gc
        last = prev;//最後一個節點指針指向prev
        if (prev == null)//若是是惟一的節點
            first = null;//第一個節點的指針也置空
        else
            prev.next = null;//不然上一個節點的next置空，（因爲成爲新的最後一個節點，最後一個節點沒有next）
        size--;//數據量減1
        modCount++;
        return element;//返回取消的數據
    }

unlink(Node<E> x)取消某一個節點

E unlink(Node<E> x) {
        // assert x != null;斷言節點x不是空的
        final E element = x.item;//獲取節點值
        final Node<E> next = x.next;//獲取節點的next
        final Node<E> prev = x.prev;//獲取節點的pre

        if (prev == null) {//若是x是首節點
            first = next;//first指向next
        } else {//x不是首節點
            prev.next = next;//不然上一個節點next指向下一個節點
            x.prev = null;//x的上一個節點引用置空
        }

        if (next == null) {//若是x是尾節點
            last = prev;//last的指針指向pre
        } else {//x不是尾節點
            next.prev = prev;//下一個節點的pre指向上一個節點
            x.next = null;//下一個節點的引用置空
        }

        x.item = null;//x的值置空
        size--;//數據量減1
        modCount++;
        return element;//返回移除的數據
    }

getFirst()獲取第一個節點的值

public E getFirst() {
        final Node<E> f = first;
        if (f == null)//空的集合
            throw new NoSuchElementException();
        return f.item;//返回第一個節點指針，指向節點，包含的值
    }

getLast()返回最後一個節點的值

public E getLast() {
        final Node<E> l = last;
        if (l == null)//空的集合
            throw new NoSuchElementException();
        return l.item;
    }

removeFirst()刪除第一個節點指針，指向的節點

public E removeFirst() {
        final Node<E> f = first;
        if (f == null)//空的集合
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

removeLast()刪除最後一個節點指針，指向的節點

public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

addFirst(E e)在第一個節點指針，指向節點的，前面插入節點e

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

addLast(E e)在第最後一個節點指針，指向節點的，後面插入節點e

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

contains(Object o)查看集合是否存在對象o

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

indexOf(Object o)返回指定元素第一次出現的索引

public int indexOf(Object o) {
        int index = 0;//初始索引下標0
        if (o == null) {//o爲空的時候
            for (Node<E> x = first; x != null; x = x.next) {//從第一個節點指針指向的節點循環到最後一個節點（最後一個節點指針last指向的節點的next是null）
                if (x.item == null)//直接對比內存地址
                    return index;//對等返回index
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {//從第一個節點指針指向的節點循環到最後一個節點（最後一個節點指針last指向的節點的next是null）
                if (o.equals(x.item))//調用o的equals方法
                    return index;//對等返回index
                index++;
            }
        }
        return -1;//沒有找到返回-1
    }