知其然知其因此然之LinkedList经常使用源码阅读

时间 2019-11-30

原文原文链接

Hello你们好，本章咱们简单了解一下LinkedList 。有问题能够联系我mr_beany@163.com。另求各路大神指点，感谢。

说明：本篇文章基于jdk1.8进行阅读，并针对LinkedList中经常使用的一些方法进行简要说明。java

一：LinkedList简介

LinkedList是一种链表类型的数据结构，支持高效的插入和删除操做。其实现了 Deque 接口，使得 LinkedList具备队列的特性。LinkedList 类的底层实现的数据结构是一个双端的链表。node

二：数据结构图分析

如图能够看出LinkedList数据结构使用双向链表结构，有一个头节点和一个尾节点，第一个节点的前驱节点为null，最后一个节点的后继节点为null。其中每一个节点有两个指针指向前驱节点和后继节点，这意味着咱们在添加或修改LinkedList时没必要像ArrayList同样进行扩容操做。数组

三：继承关系分析

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

继承于 AbstractSequentialList。而AbstractSequentialList这个类提供了一个基本的 List 接口实现，为实现序列访问的数据储存结构的提供了所须要的最小化的接口实现。他采用的是在迭代器的基础上实现的 get、set、add 和 remove 方法。
实现List接口，说明能够对他进行队列的操做
实现Deque接口，能够将 LinkedList 看成双端队列使用
实现Cloneable接口，说明能够进行克隆
实现Serializable接口，说明能够被序列化

四：源码分析

1：成员变量安全

//transient修饰的变量在序列化时不会被序列化   
transient int size = 0;

/**
 * Pointer to first node.
 * Invariant: (first == null && last == null) ||
 *            (first.prev == null && first.item != null)
 */
transient Node<E> first;

/**
 * Pointer to last node.
 * Invariant: (first == null && last == null) ||
 *            (last.next == null && last.item != null)
 */
transient Node<E> last;复制代码

LinkedList的成员变量很简单，只有三个。其中size表示链表中实际元素的数量。bash

根据注释结合上面的数据结构图能够看出：数据结构

当链表为空时，first和last必定都为空。
当链表不为空时，first的前驱结点必定为空，first.item必定不为空。last的后续节点必定为空，last.item必定不为空。

2：内部类函数

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;
    }
}复制代码

3：构造方法工具

//构建一个空列表
public LinkedList() {
}

/**
 * 构建一个包含集合c的列表
 *
 * @param  c the collection whose elements are to be placed into this list
 * @throws NullPointerException if the specified collection is null
 */ 
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}复制代码

4：经常使用方法源码分析

添加元素到第一个节点

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++;
}复制代码

分析，经过变量f存储第一个节点，接下来调用Node建立一个新的节点，将新节点做为新first，这时判断，若是以前的first为空，那说明插入以前该链表是空的，那么新插入的节点不只是first节点并且仍是last节点，因此last要指向新插入的 newNode。优化

若是以前的first不是空，那么不动last，将first的前驱结点设为新节点，此时原first节点为链表的第二个节点。

最后插入成功，将链表节点数量加一

说明：Fail-Fast 机制

变量modCount为记录当前链表被修改的次数。咱们知道LinkedList是线程不安全的，在迭代器遍历链表时，迭代器初始化过程当中会将这个值赋给迭代器的expectedModCount。在迭代过程当中，判断modCount跟expectedModCount 是否相等，若是不相等就表示已经有其余线程修改了。那么将抛出 ConcurrentModificationException。因此当你们遍历那些非线程安全的数据结构时，尽可能使用迭代器进行遍历。

重点：向链表中添加元素

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

//添加指定集合到指定位置
public boolean addAll(int index, Collection<? extends E> c) {
        //判断须要插入的位置是否合法  index>=0且index小于等于当前链表节点数量
        checkPositionIndex(index);
        //将集合转换为数组
        Object[] a = c.toArray();
        //保存集合长度
        int numNew = a.length;
        if (numNew == 0)
            return false;

        //建立节点  前驱节点，后续节点
        Node<E> pred, succ;
        //若是插入的节点为链表的末端，则前驱节点为尾节点，后续节点为空
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            //根据节点位置获取该节点  下面分析
            succ = node(index);
            //保存该节点的前驱节点，这里咱们将链表断开，准备将集合插入指定位置  succ保存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;
            //将前驱改为当前节点，以便后续添加c中其它的元素
            pred = newNode;
        }

        //仍是两种判断 若是succ为空，说明插入的节点位置是该链表的尾节点的后面
        //这时经过上面的遍历咱们能够知道，pred确定指向当前链表最后一个节点，因此将last指向pred
        if (succ == null) {
            last = pred;
        } else {
            //此时咱们须要将以前断开的链表的后半部分拼接上。pred为当前重组的尾节点，
            //则尾节点的后续节点指向succ，succ的前驱节点指向pred
            pred.next = succ;
            succ.prev = pred;
        }
        //链表长度增长
        size += numNew;
        //操做次数增长
        modCount++;
        return true;
    }复制代码

获取指定位置的节点

//这里咱们能够看到对此查找，LinkedList是作了优化的，
//并无盲目的去所有遍历，而是判断要查找的坐标离头节点近仍是尾节点近，来判断是从头遍历仍是从尾开始遍历
Node<E> node(int index) {
    // assert isElementIndex(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;
    }
}复制代码

删除一个元素（元素不为空

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;
}复制代码

删除 LinkedList 中第一个节点（私有

//根据注释咱们能够看出元素必须是第一个元素且不能为空
private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    //存储待删除节点的值，用做删除成功返回带=待删除节点的值
    final E element = f.item;
    //存储待删除节点的后续节点
    final Node<E> next = f.next;
    //把f的值和它的next设置为空
    f.item = null;
    f.next = null; // help GC
    //将他的下一个节点设置为头节点
    first = next;
    //判断next是否为空，若是为空证实原链表只有一个节点，删除以后是空链表
    if (next == null)
        //将last也须要设置为空号
        last = null;
    else
        //这是next已经为头节点，须要将头节点的前驱节点设置为空
        next.prev = null;
    //链表元素数量减一
    size--;
    //操做次数加一
    modCount++;
    return element;
}复制代码

删除 LinkedList 的最后一个节点。（该节点不为空

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;
        //判断prev是否为空，若是为空证实原链表只有一个节点，删除以后是空链表
        if (prev == null)
            first = null;
        else
            //将尾节点的后续节点设置为空
            prev.next = null;
        size--;
        modCount++;
        return element;
    }复制代码

工具函数

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

    /**
     * Removes and returns the last element from this list.
     *
     * @return the last element from this list
     * @throws NoSuchElementException if this list is empty
     */
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }复制代码

五：总结

元素源码咱们能够看出LinkedList在添加删除元素时，不须要像ArrayList同样去扩容。而在根据元素所在位置去查找元素时又不像ArrayList中同样直接去取，而是须要遍历。因此LinkedList更多的适用于频繁添加删除，而查找很少的场景下。

根据位置查找元素时先判断离头节点近仍是尾节点近这种优化方式咱们也能够用于平常的代码中

LinkedList是线程不安全的，在遍历的过程当中咱们尽可能使用迭代器进行遍历