【Java集合源码剖析】LinkedList源码剖析

推荐一篇分析LinkedList的博客，非常不错：传送门

LinkedList是基于双向链表（从源码中可以很容易看出）实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。

LinkedList同样是非线程安全的，只在单线程下适合使用。

LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。

源码如下。

public class LinkedList<E>        extends AbstractSequentialList<E>        implements List<E>, Deque<E>, Cloneable, java.io.Serializable{    // 链表尺寸    transient int size = 0;    /**     * 头结点     * Invariant: (first == null && last == null) ||     *            (first.prev == null && first.item != null)     */    transient Node<E> first;    /**     * 头结点     * Invariant: (first == null && last == null) ||     *            (last.next == null && last.item != null)     */    transient Node<E> last;    /**     * Constructs an empty list.     */    public LinkedList() {    }    /**     * 链接新元素到头部     */    private void linkFirst(E e) {        // 记录在头部添加元素前的头指针        final Node<E> f = first;        // 创建新结点        final Node<E> newNode = new Node<>(null, e, f);        // 头结点指针指向新结点        first = newNode;        // 如果链表还是空表，则尾指针也指向新结点，否则，将新结点链接到头部        if (f == null)            last = newNode;        else            f.prev = newNode;        // 尺寸增加        size++;        modCount++;    }    /**     * 链接新元素到尾部     */    void linkLast(E e) {        // 记录在尾部添加元素前的尾指针        final Node<E> l = last;        // 创建新结点        final Node<E> newNode = new Node<>(l, e, null);        // 尾指针指向新节点        last = newNode;        // 如果链表还是空表，则头指针也指向新结点，否则将新结点链接到尾部        if (l == null)            first = newNode;        else            l.next = newNode;        // 尺寸增加        size++;        modCount++;    }    /**     * 在succ结点前插入元素e     */    void linkBefore(E e, Node<E> succ) {        // 记录succ结点的前驱        final Node<E> pred = succ.prev;        // 生成新结点，并链接到succ结点的前驱和succ结点本身。        final Node<E> newNode = new Node<>(pred, e, succ);        // 更新succ的直接前驱结点为新结点        succ.prev = newNode;        // 如果记录的succ结点的前驱为null，说明插入的位置位于头部，则让头指针指向新结点，否则更新其后驱为新结点        if (pred == null)            first = newNode;        else            pred.next = newNode;        // 尺寸增加        size++;        modCount++;    }    /**     * 断开头部f结点的链接，     */    private E unlinkFirst(Node<E> f) {        // assert f == first && f != null;        final E element = f.item;        final Node<E> next = f.next;        f.item = null;        f.next = null; // help GC        first = next;        if (next == null)            last = null;        else            // 非空表，则置空新的头结点元素的前驱            next.prev = null;        // 减少尺寸        size--;        modCount++;        return element;    }    /**     * 断开尾部l结点的链接     */    private E unlinkLast(Node<E> l) {        // assert l == last && l != null;        final E element = l.item;        final Node<E> prev = l.prev;        l.item = null;        l.prev = null; // help GC        last = prev;        if (prev == null)            first = null;        else            prev.next = null;        size--;        modCount++;        return element;    }    /**     * 断开结点x，并返回其item     */    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;        // 更新断开处的前驱        if (prev == null) {            first = next;        } else {            prev.next = next;            x.prev = null;        }        // 更新断开处的后驱        if (next == null) {            last = prev;        } else {            next.prev = prev;            x.next = null;        }        x.item = null;        size--;        modCount++;        return element;    }    /**     * 获取头结点元素     */    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 removeFirst() {        final Node<E> f = first;        if (f == null)            throw new NoSuchElementException();        return unlinkFirst(f);    }    /**     * 移除尾结点元素     */    public E removeLast() {        final Node<E> l = last;        if (l == null)            throw new NoSuchElementException();        return unlinkLast(l);    }    /**     * 添加元素到头结点     */    public void addFirst(E e) {        linkFirst(e);    }    /**     *  添加元素到尾结点     */    public void addLast(E e) {        linkLast(e);    }    /**     * 添加指定的元素到链表的尾部.     * 和addLast()方法行为一致.     */    public boolean add(E e) {        linkLast(e);        return true;    }    /**     * 获取指定位置的元素     */    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;    }    /**     * 插入新元素到指定位置     */    public void add(int index, E element) {        // 检查插入位置是否合法        checkPositionIndex(index);        // 如果是尾部，则直接链接到尾部，否则先查找到指定为的元素，然后在其前链接元素。        if (index == size)            linkLast(element);        else            linkBefore(element, node(index));    }    /**     * 获取指定索引的元素     */    Node<E> node(int 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;        }    }    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的Object[]数组        public Object[] toArray() {        Object[] result = new Object[size];        int i = 0;        for (Node<E> x = first; x != null; x = x.next)            result[i++] = x.item;        return result;    }    // 返回LinkedList的模板数组。所谓模板数组，即可以将T设为任意的数据类型    public <T> T[] toArray(T[] a) {        if (a.length < size)            a = (T[])java.lang.reflect.Array.newInstance(                    a.getClass().getComponentType(), size);        int i = 0;        Object[] result = a;        for (Node<E> x = first; x != null; x = x.next)            result[i++] = x.item;        if (a.length > size)            a[size] = null;        return a;    }    private static final long serialVersionUID = 876323262645176354L;    // Positional Access Operations 随机访问位置的方法    // set     设置index位置对应的节点的值为element      // get     返回LinkedList指定位置的元素        // remove  删除index位置的节点     // Search Operations 搜索方法    // indexOf    // lastIndexOf    // Queue operations. 队列方法    // peek    返回第一个节点    // element 返回第一个节点     // pool    删除并返回第一个节点    // remove  删除并返回第一个节点    // offer   添加指定元素到队列尾部    // Deque operations  双端队列方法    // offerFirst 添加元素到队列头部    // offerLast  添加元素到队列尾部    // peekFirst  返回队头元素    // peekLast   返回队尾元素    // pollFirst  返回并移除队头元素    // pollLast   返回并移除队尾元素    // push       添加元素到链表头部     // pop        移除链表头部的数据    // 从LinkedList开始向后查找，删除第一个值为元素(o)的节点     // 从链表开始查找，如存在节点的值为元素(o)的节点，则删除该节点        // removeFirstOccurrence      // 从LinkedList末尾向前查找，删除第一个值为元素(o)的节点     // 从链表开始查找，如存在节点的值为元素(o)的节点，则删除该节点    // removeLastOccurrence    // 返回“index到末尾的全部节点”对应的ListIterator对象(List迭代器)    // listIterator    // List迭代器    // class ListItr}

关于LinkedList的源码，给出几点比较重要的总结：

1， 从源码中可以看出，LinkedList的实现是基于双向链表的，始终有头指针指向第一个结点，有尾指针指向最后一个结点。

2，注意两个不同的构造方法。无参构造方法中没有做任何事情，包含Collection的构造方法，将Collection中的数据加入到链表的尾部后面。

3，在查找和删除某元素时，源码中都划分为该元素为null和不为null两种情况来处理，LinkedList中允许元素为null。

4，LinkedList是基于链表实现的，因此不存在容量不足的问题，所以这里没有扩容的方法。

5，源码中node(int index)方法，该方法返回双向链表中指定位置处的节点，而链表中是没有下标索引的，要指定位置出的元素，就要遍历该链表，从源码的实现中，我们看到这里有一个加速动作。源码中先将index与长度size的一半比较，如果index<size/2，就只从位置0往后遍历到位置index处，而如果index>size/2，就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历，从而提高一定的效率（实际上效率还是很低）。

6，LinkedList是基于链表实现的，因此插入删除效率高，查找效率低（虽然有一个加速动作）。

7，在源码中提供了栈，队列，双端队列的操作方法，因此可以作为栈和双端队列使用。