Java集合之LinkedList源码解析

概述

• 是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。
• 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

• 实现 List 接口，能对它进行队列操作。
• 实现 Deque 接口(带可)，即能将LinkedList当作双端队列使用。

• 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
• 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

• 是非同步，线程不安全的。

数据结构

 如上图所示，LinkedList底层使用的双向链表结构，有一个头结点和一个尾结点，双向链表意味着我们可以从头开始正向遍历，或者是从尾开始逆向遍历，并且可以针对头部和尾部进行相应的操作。

特性

1）异步，也就是非线程安全

2）双向链表。由于实现了list和Deque接口，能够当作队列来使用。

链表：查询效率不高，但是插入和删除这种操作性能好。

3）是顺序存取结构

源码分析

类的属性

​// 实际元素个数，链表长度transient int size = 0;
// 头结点transient Node<E> first;
// 尾结点transient Node<E> last;

LinkedList的属性非常简单，一个头结点、一个尾结点、一个表示链表中实际元素个数的变量。

构造方法

两个构造方法(两个构造方法都是规范规定需要写的）

1）空参构造函数

**
* Constructs an empty list.
*/public LinkedList() {
}

2）有参构造函数

//将集合c中的各个元素构建成LinkedList链表。public LinkedList(Collection<? extends E> c) {
    // 调用无参构造函数
    this();
    // 添加集合中所有的元素
    addAll(c);
}

说明：会调用无参构造函数，并且会把集合中所有的元素添加到LinkedList中。

内部类（Node）

//根据前面介绍双向链表就知道这个代表什么了，linkedList的奥秘就在这里。

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

说明：内部类Node就是实际的结点，用于存放实际元素的地方。

核心方法

1 add()方法

私有方法

LinkedList 内部有几个关键的私有方法，它们实现了链表的插入、删除等操作。比如在表头插入：

private void linkFirst(E e) {
    final Node<E> f = first;    //先保存当前头节点
    //创建一个新节点，节点值为e，前驱节点为空，后继节点为当前头节点
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;    //让first指向新节点
    if (f == null)    //如果链表原来为空，把last指向这个唯一的节点
        last = newNode;
    else    ·        //否则原来的头节点的前驱指向新的头节点
        f.prev = newNode;
    size++;
    modCount++;
}
其实就是双向链表的插入操作，调整指针的指向，时间复杂度为 O(1) ，学过数据结构的应该很容易看懂。其它还有几个类似的方法：//尾部插入void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)    //如果链表原来为空，让first指向这个唯一的节点
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}//中间插入void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    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++;
}//删除头节点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;    //让first指向下一个节点
    if (next == null)    //如果下一个节点为空，说明链表原来只有一个节点，现在成空链表了，要把last指向null
        last = null;
    else        //否则下一个节点的前驱节点要置为null
        next.prev = null;
    size--;
    modCount++;
    return element;
}//删除尾节点
 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;    //last指向前一个节点
    if (prev == null)    //与头节点删除一样，判断是否为空
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}//从链表中间删除节点
 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要指向下一个节点
        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;
}

1）add(E)

说明：add函数用于向LinkedList中添加一个元素，并且添加到链表尾部。具体添加到尾部的逻辑是由linkLast函数完成的。

public boolean add(E e) {
    // 添加到末尾
    linkLast(e);
    return true;
}

LinkLast()//尾部插入

/**
     * Links e as last element.
     */void linkLast(E e) {
    final Node<E> l = last;    //临时节点l(L的小写)保存last，也就是l指向了最后一个节点
    final Node<E> newNode = new Node<>(l, e, null);//将e封装为节点，并且e.prev指向了最后一个节点
    last = newNode;//newNode成为了最后一个节点，所以last指向了它
    if (l == null)    //判断是不是一开始链表中就什么都没有，如果没有，则newNode就成为了第一个节点，first和last都要指向它
        first = newNode;
    else    //正常的在最后一个节点后追加，那么原先的最后一个节点的next就要指向现在真正的最后一个节点，原先的最后一个节点就变成了倒数第二个节点
        l.next = newNode;
    size++;//添加一个节点，size自增
    modCount++;
}

举例：

 

List<Integer> lists = new LinkedList<Integer>();

lists.add("e1");

lists.add("e2");

一开始，first和last都为null，此时链表什么都没有，当第一次调用该方法后，first和last均指向了第一个新加的节点E1：

 

第二次调用该方法，加入新节点E2。首先，将last引用赋值给l，接着new了一个新节点E2，并且E2的prve指向l，接着将新节点E2赋值为last

接着判断l==null? 所以走的else语句，将l的next引用指向新节点E2

最后，size+1，modCount+1，退出该方法，局部变量l销毁

公开的方法几乎都是调用上面几个方法实现的，例如 add 方法：

public boolean add(E e) {
    linkLast(e);
    return true;
}public boolean add(E e) {
    linkLast(e);
    return true;
}public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

add(int index, E element)的逻辑稍显复杂，可以分成两部，1.先根据index找到要插入的位置；2.修改引用，完成插入操作。

//add(int index, E element)public void add(int index, E element) {
    checkPositionIndex(index);//index >= 0 && index <= size;
    if (index == size)//插入位置是末尾，包括列表为空的情况
        add(element);
    else{
         Node<E> succ = node(index);//1.先根据index找到要插入的位置
        //2.修改引用，完成插入操作。
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)//插入位置为0
            first = newNode;
        else
            pred.next = newNode;
        size++;
    }
}

上面代码中的node(int index)函数有一点小小的trick，因为链表双向的，可以从开始往后找，也可以从结尾往前找，具体朝那个方向找取决于条件index < (size >> 1)，也即是index是靠近前端还是后端。

2).remove()方法也有两个版本，一个是删除跟指定元素相等的第一个元素remove(Object o)，另一个是删除指定下标处的元素remove(int index)。

remove(int index)
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

remove(Object o)

//首先通过看上面的注释，我们可以知道，如果我们要移除的值在链表中存在多个一样的值，那么我们会移除index最小的那个，也就是最先找到的那个值，如果不存在这个值，那么什么也不做public boolean remove(Object o) {
    //这里可以看到，linkedList也能存储null
    if (o == null) {
        //循环遍历链表，直到找到null值，然后使用unlink移除该值。下面的这个else中也一样
        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;
}

 第一个 remove(int index) 方法同样要调用 node(index) 寻找节点。而第二个方法 remove(Object o) 是删除指定元素，这个方法要依次遍历节点进行元素的比较，最坏情况下要比较到最后一个元素，比调用 node 方法更慢，时间复杂度为 O(n) 。另外从这个方法可以看出 LinkedList 的元素可以是 null 。

3). get(index)

get(index)查询元素的方法

//这里没有什么，重点还是在node(index)中public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

node(index)

/**
     * Returns the (non-null) Node at the specified element index.
     *///这里查询使用的是先从中间分一半查找
    Node<E> node(int index) {
        // assert isElementIndex(index);//"<<":*2的几次方 “>>”:/2的几次方，例如：size<<1：size*2的1次方，//这个if中就是查询前半部分
         if (index < (size >> 1)) {//index<size/2
            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;
        }
    }

 4).set(int index, E element)方法将指定下标处的元素修改成指定值，也是先通过node(int index)找到对应下表元素的引用，然后修改Node中item的值。

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

5). indexOf(Object o)

//这个很简单，就是通过实体元素来查找到该元素在链表中的位置。跟remove中的代码类似，只是返回类型不一样。public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

总结

1）linkedList本质上是一个双向链表，通过一个Node内部类实现的这种链表结构。

 2）能存储null值

 3）跟arrayList相比较，就真正的知道了，LinkedList在删除和增加等操作上性能好，而ArrayList在查询的性能上好 

4）从源码中看，它不存在容量不足的情况

5）linkedList不光能够向前迭代，还能像后迭代，并且在迭代的过程中，可以修改值、添加值、还能移除值。

 6）linkedList不光能当链表，还能当队列使用，这个就是因为实现了Deque接口。