LinkedList源码解析（基于JDK1.7）

一、LinkedList简介

LinkedList的内部实现是双向链表，它继承了AbstractSequentialList，实现了List, Deque, Cloneable, Java.io.Serializable接口，因此LinkdeList本身支持就支持双端队列操作。LinkedList可以存储所有元素（包括 null）。LinkedList可以用作堆栈、队列或双端队列的实现。其内部链表的实现原理如下：

可以看到这是一个双向链表的结构，而在JDK1.6中，其实现如下：

可以看到在1.6中，存在环形结构，自然在代码中的也会有部分的改变。本次分析基于JDK1.7。
LinkedList与ArrayList一样实现List接口，只是ArrayList是List接口的大小可变数组的实现，LinkedList是List接口链表的实现。基于链表实现的方式使得LinkedList在插入和删除时更优于ArrayList，而随机访问则比ArrayList逊色些。
LinkedList的实现不是同步的。如果在多线程环境下，应该使用 Collections.synchronizedListxxx 方法来“包装”LinkedList。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：

List list = Collections.synchronizedList(new LinkedList(...));

LinkedList的 iterator 和 listIterator 方法返回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，这是通过LinkedList的modCount属性实现的。

二、源码分析

1、定义

LinkedList的定义如下：

public class LinkedList<E>  
    extends AbstractSequentialList<E>  
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable  

• Serializable：
  序列化接口没有方法或字段，仅用于标识可序列化的语义
• Iterable：
  实现这个接口允许对象成为 “foreach” 语句的目标。
• Cloneable：
  此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。
• AbstractSequentialList
  此类提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作。对于随机访问数据（如数组），应该优先使用 AbstractList，而不是先使用此类。
• Deque
  一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

2、关键属性

    transient int size = 0;//链表元素个数  
    transient Node<E> first;//链表头结点 
    transient Node<E> last;//链表尾结点  

和ArrayList类似，在类内部同样出现了transient关键字，这在ArrayList中已经解释过了，在这里不做过多的解释了。
LinkedList内部通过Node来抽象一个节点，结点包括值和前向指针和后向指针。Node的定义是在LinkedList内部，作为静态内部类存在。

private static class Node<E> {  
        E item;//结点的值  
        Node<E> next;//结点的后向指针  
        Node<E> prev;//结点的前向指针   
        //构造函数中已完成Node成员的赋值 
        Node(Node<E> prev, E element, Node<E> next) {  
            this.item = element;//结点的值赋值为element  
            this.next = next;//后向指针赋值  
            this.prev = prev;//前向指针赋值  
        }  
}

3、构造方法

LinkedList构造方法有两个，一个是无参构造，一个是传入Collection对象的构造。源码如下：

    // 什么都没做，是一个空实现
    public LinkedList() {
    }

    //传入一个集合类
    public LinkedList(Collection<? extends E> c) {
        this();//就是上面的空实现
        addAll(c);
    }

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

    public boolean addAll(int index, Collection<? extends E> c) {
        // 检查传入的索引值是否在合理范围内
        checkPositionIndex(index);
        // 将给定的Collection对象转为Object数组
        Object[] a = c.toArray();
        int numNew = a.length;
        // 数组为空的话，直接返回false
        if (numNew == 0)
            return false;
        // 数组不为空
        Node<E> pred, succ;
        if (index == size) {
            // 构造方法调用的时候，index = size = 0，进入这个条件。
            succ = null;
            pred = last;
        } else {
            // 链表非空时调用，node方法返回给定索引位置的节点对象
            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)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        if (succ == null) {
            last = pred; // 将当前链表最后一个节点赋值给last
        } else {
            // 链表非空时，将断开的部分连接上
            pred.next = succ;
            succ.prev = pred;
        }
        // 记录当前节点个数
        size += numNew;
        modCount++;
        return true;
    }

这两个构造方法概括起来就是：无参构造为空实现。有参构造传入Collection对象，将对象转为数组，并按遍历顺序将数组首尾相连，全局变量first和last分别指向这个链表的第一个和最后一个。
对于addAll方法，其返回值为boolean类型，当插入的集合元素为空时，才返回false，其他情况下返回true。

4、addFirst和addLast方法源码

addFirst的源码实现如下：

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

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;  //此时链表中只有一个节点，first和last都指向该节点
    else  //原本链表不为空
        f.prev = newNode;//维护双向链表的关系  
    size++;  //节点个数加1
    modCount++;  
}  

addFirst顾名思义，是在现在的链表的头部加一个节点。既然是头结点，那么头结点的前继必然为null，所以这也是Node<E> newNode = new Node<>(null, e, f);这样写的原因。之后将first指向了当前链表的头结点，若在插入元素之前头结点为null，则当前加入的元素就是第一个节点，也就是头结点，所以当前的状况就是：头结点=刚刚加入的节点=尾节点。若在插入元素之前头结点不为null，则证明之前的链表是有值的，那么我们只需要来维护双向链表，即原头节点的前置节点为新插入的节点，而尾节点则没有发生变化。这样一来，原来的头结点就变成了第二个节点了。达到了我们的目的。

addLast方法在实现上是个addFirst是一致的，源码如下：

 //添加到尾结点，结点值为e  
    public void addLast(E e) {  
        linkLast(e);//添加到尾部  
    }  
     //尾部增加结点，结点的值为e  
    private void linkLast(E e) {  
        final Node<E> l = last;//l指向尾结点  
        //生成一个新结点，结点的值为e，其前向指针为l，后向指针为null  
        final Node<E> newNode = new Node<>(l, e, null);
        //last指向新生成的结点,l保存着老的尾结点信息  
        last = newNode;
        if (l == null)  
            //如果l为null,则表示整个链表目前是空的，则头结点也指向新结点
            first = newNode;  
        else  
            //l(老的尾结点)的后向指针指向最新的结点信息
            l.next = newNode;  
        size++;//元素个数+1  
        modCount++;//修改次数+1  
    }  

5、add(E e)和add(int index, E element)方法

add(E e)将指定元素添加到此列表的结尾。此方法等效于 addLast(E)。其源码如下：

public boolean add(E e) {
        linkLast(e);
        return true;
    }

方法add(int index, E element)表示在此列表中指定的位置插入指定的元素。随机写入，也就是使用下标，都要进行循环链表找到对应的链表节点找到节点之后，写入很快，（不用向数组那样还需要移动n个元素的下标）。需要注意的是，这里检索下标是从0开始，其源码如下：

  //在指定位置插入元素，如果该位置已经有了元素，则改变这个元素的前/后索引
    public void add(int index, E element) {
        checkPositionIndex(index); // 同样检查索引是否越界
        if (index == size) //如果下标等于此列表的大小，则相当于往列表末尾添加元素（下标从0开始）
            linkLast(element);
        else
            linkBefore(element, node(index));
    }
   //非空结点succ之前插入新结点，新结点的值为e  
   private void linkBefore(E e, Node<E> succ) {  
        // assert succ != null;//外界调用需保证succ不为null,否则程序会抛出空指针异常  
        final Node<E> pred = succ.prev;//pred指向succ的前向结点  
        //生成一个新结点，结点的值为e,其前向指针指向pred，后向指针指向succ  
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;//succ的前向指针指向newNode  
        if (pred == null)  
            //如果pred为null，则表示succ为头结点，此时头结点指向最新生成的结点newNode  
            first = newNode;
        else  
            //pred的后向指针指向新生成的结点，此时已经完成了结点的插入操作
            pred.next = newNode;  
        size++;//元素个数+1  
        modCount++;//修改次数+1  
    }  

6、getFirst和getLast方法