Java源码分析(三)--LinkedList

概述：

LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList 实现 List 接口，能对它进行队列操作。
LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
LinkedList 是非同步的。

能够插入null值。

源码分析：

1、基本属性：

/** 链表长度 */
transient int size = 0;

/** 表示链表首尾对象 */
transient Node<E> first;
transient Node<E> last;

/** Node<E>描述 */
    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;
        }
    }

2、构造方法：

    /** 构造空表 */
    public LinkedList() {
    }

    /** 
    * 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。 
    */
     public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

    /**
    * 无添加位置调用addAll(int ,Collection )
    */
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, 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;

        /** 
        * pred表示插入节点的前一节点，
        * succ表示插入节点的后一节点，
        * 插入节点newNode放中间 
        */
        Node<E> pred, succ;

        /** 讨论插入位置是否为末尾的情况，确定pred,succ */
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }

        /** 
        * 下面新建节点很巧妙，new Node<>(pred,e,null) ,
        * 而不是 ， new Node<>(pred,e,succ)
        * 这么做很方便处理last这个尾指针
        */

        /** 连接首部 */
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);//！！
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        /** 连接尾部 */
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        /** 修改链表长度，更新次数 */
        size += numNew;
        modCount++;
        return true;
    }

3、主要方法：
(对push,poll等特定方法的实现，都是通过对first,last与下列各种方法组合实现的)

add ，普通的add(E e)在末尾添加，则是调用的add(size,e)实现的。

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));//linkBefore与node(index)见下一个
    }

linkBefore，它的实现，能够方便人们在各个位置插入

    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;

        /**
        * 这里提到succ!=null，
        * 事实上在LinkedList里，如果succ==null，则意味着尾部，
        * 有单独的linkLast(E e)方法特殊处理
        */
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        /** 首节点的特处理 */
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;

        /** 长度，更新次数的修改 */
        size++;
        modCount++;
    }

node(int index) ，取得第index个元素的句柄，

    /**
    * 有趣的是它将链表对半分，选择近的一端开始迭代，
    * 事实上，indexOf()，与lastIndexOf()也采用了相同的思路。
    */
    Node<E> node(int index) {
        // assert isElementIndex(index);

        /** 小index正向迭代 */
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        }
        /** 大index反向迭代 */ 
        else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

remove

remove()移除链首
remove(int)
remove(Object)
removeFirst()
removeLast()
这些都差不多，调用了关键方法unlink

    /**
    * 这是remove源码
    * 能够对null元素处理
    */
    public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    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;
    }

    /** 
    * 这是unlink源码
    */
    E unlink(Node<E> x) {
        // assert x != null;
        // 和上面的Object不同，这里的Node<E> x是指针，可不能为空
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        /** 
        * 处理首部分，对first特处理
        * 并且将x.prev置null
        */
        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        /** 
        * 处理尾部分，对last特处理
        * 并且将x.next置null
        */
        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        /** 
        * 最后将x.item置null
        */
        x.item = null;

        size--;
        modCount++;
        return element;
    }

clear

从首部迭代，依次清空

    public void clear() {
        // Clearing all of the links between nodes is "unnecessary", but:
        // - helps a generational GC if the discarded nodes inhabit
        //   more than one generation
        // - is sure to free memory even if there is a reachable Iterator
        for (Node<E> x = first; x != null; ) {
            Node<E> next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }

get && set

    /** 
    * 前面解释过node(index)这个方法 
    * 需要注意的是返回值类型为E
    */
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

clone

    /** 一个一个地添加过去的额 */
    public Object clone() {
        LinkedList<E> clone = superClone();

        // Put clone into "virgin" state
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;

        // Initialize clone with our elements
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);

        return clone;
    }