二、LinkedList源码分析

1、LinkedList概述

1）LinkedList是线程不安全的，允许元素为null的双向链表。
2）底层数据结构是链表，实现了Deque接口，所以可作为一个双端队列。和ArrayList比，没有实现RandomAccess，所以它以下标随机访问元素速度较慢，即查询效率不高。
3）在根据下标index查询Node的时候，会根据index判断目标Node在前半段还是后半段，然后决定是顺序还是逆序查询，以提升时间效率。不过随着n的增大，总体时间效率依然很低。每次查询操作必须进行遍历。
4）因其底层数据结构是链表，可以在任何位置进行高效地插入和移除操作，即增删效率高。
5）LinkedList和Collection的关系：

2、LinkedList的数据结构

LinkedList的数据结构是：

说明：可以看出，LinkedList底层使用的双向链表结构。双向链表包含两个指针和一个element，element用来存放元素，pre指向前一个节点，next指向后一个节点，但是第一个节点（头节点）的pre指向null，最后一个节点（尾结点）的next指向null。

3、LinkedList源码分析

3.1继承结构和层次关系

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

LinkedList的继承结构：
LinkedList extends AbstractSequentialList
AbstractSequentialList extends AbstractList
AbstractList extends AbstractCollection
所有类都继承Object类，所以LinkedList的继承结构就是上图所示。

注意：
1）ArrayList只有四层，为什么LinkedList多了一层AbstractSequentialList的抽象类？
为了减少实现顺序遍历（例如LinkedList）这种类的工作，抽象出这种类的共同方法，若想实现链表形式的类就继承AbstractSequentialList，若想实现数组形式的类就继承AbstracList。
2）LinkedList实现了哪些接口？
①List接口：ArrayList的父类AbstractList也实现了List接口，为什么子类ArrayList还去实现一遍呢？开发这个collection 的作者Josh说，这其实是一个mistake，因为他写这代码的时候觉得这个会有用处，但是其实并没什么用，但因为没什么影响，就一直留到了现在。
②Deque接口：表示是一个双端队列，意味着LinkedList是双端队列的一种实现，所以，基于双端队列的操作在LinkedList中全部有效。
③Cloneable接口：是一个标记性接口，实现了该接口，表示该对象能被克隆，能使用Object.clone()方法。没实现该接口调用Object.clone()方法就会抛出CloneNotSupportedException。
④Serializable接口：实现该序列化接口，表明该类可以被序列化。什么是序列化？简单的说，就是能够从类变成字节流传输，然后还能从字节流变成原来的类。
⑤注意到没有RandomAccess接口：那么就推荐使用iterator遍历，或foreach，其原理就是iterator。

3.2成员变量

LinkedList的属性非常简单，一个头结点，一个尾结点，一个表示链表中实际元素个数的变量。注意：头结点、尾结点都有transient关键字修饰，这意味着在序列化时该域不会序列化。

//记录当前链表的长度（实际元素个数）
transient int size = 0;
//头结点
transient Node first;
//尾结点
transient Node last;

3.3构造方法

LinkedList有两个构造方法：
1）空参构造函数

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

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

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

3.4内部类（Node节点）

    private static class Node {
        E item;// 数据域（当前节点的值）
        Node next;// 后继（指向当前一个节点的后一个节点）
        Node prev;// 前驱（指向当前节点的前一个节点）

        // 构造函数，赋值前驱后继
        Node(Node prev, E element, Node next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

3.5核心方法

3.5.1 增

add相关方法中主要用到三个辅助方法：
linkFirst(E e)：把参数中的元素作为链表的第一个元素。
linkLast(E e)：把参数中的元素作为链表的最后一个元素。
linkBefore(E e, Node succ)：在非空节点succ前插入元素e。

1）boolean add(E e)：向链表尾部添加一个元素，具体添加到尾部的逻辑是由linkLast函数完成的。

//在尾部插入一个节点： add
public boolean add(E e) {
    linkLast(e);
    return true;
}

//生成新节点 并插入到 链表尾部， 更新 last/first 节点。
void linkLast(E e) { 
 //记录原尾部节点
    final Node l = last;
//以原尾部节点为前置节点的新节点
    final Node newNode = new Node<>(l, e, null);
//将新节点作为尾部节点
    last = newNode;
//判断一下l是否为空，若为空，说明原来的LinkedList为空，所以也需要把新节点设置为头节点。
    if (l == null)
        first = newNode;
    else
//否则将原尾节点的后置节点指向新节点（即现在的尾节点）
        l.next = newNode;
    size++;//修改size
    modCount++;//修改modCount
}

2）void add(int index, E element)：在指定下标处插入一个节点，具体添加的逻辑是由linkBefore函数完成的。

    public void add(int index, E element) {
        checkPositionIndex(index);//检查下标是否越界[0,size]
        if (index == size)//在尾节点后插入
            linkLast(element);
        else//在中间插入
            linkBefore(element, node(index));
    }

//检查下标是否越界[0,size]
    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    //在非空节点succ前，插入一个新节点e
    void linkBefore(E e, Node succ) {
        // assert succ != null;
        //pred 指向succ的前置节点
        final Node pred = succ.prev;
        //构建新节点，其前置节点为pred，后置节点为succ
        final Node newNode = new Node<>(pred, e, succ);
        //修改succ的prev为新节点
        succ.prev = newNode;
        if (pred == null)
//如果之前的前置节点是空，说明succ是原头结点。
//所以将新节点改为现在的头节点
            first = newNode;
        else
//否则修改succ的前一个节点的next为新节点
            pred.next = newNode;
        size++;//修改数量
        modCount++;//修改modCount
    }

//获取下标为index的节点
    Node node(int index) {
        // assert isElementIndex(index);
//通过下标获取某个node 的时候（增、查 ），
//判断index处于前半段还是后半段，进行折半，以提升查询效率
        if (index < (size >> 1)) {// 插入位置在前半段
            Node x = first;
            for (int i = 0; i < index; i++)// 从头结点开始正向遍历
                x = x.next;
            return x;
        } else {
            Node x = last;// 插入位置在后半段
            for (int i = size - 1; i > index; i--)// 从尾结点开始反向遍历
                x = x.prev;
            return x;
        }
    }

3）addAll方法
有两个重载函数，addAll(Collection c)型和addAll(int, Collection)型，平时习惯调用的addAll(Collection)型会转化为addAll(int, Collection)型。

//在尾部批量增加
public boolean addAll(Collection c) {
    return addAll(size, c);//以size为插入下标，插入集合c中所有元素
}

//以index为插入下标，插入集合c中所有元素
public boolean addAll(int index, Collection c) {
    checkPositionIndex(index);//检查是否越界， [0,size] 闭区间

//先把集合转化为数组，然后为该数组添加一个新的引用a
    Object[] a = c.toArray();
    int numNew = a.length;//新增元素的数量
    if (numNew == 0)//如果新增元素数量为0，直接返回false
        return false;

//Node succ：指代待添加节点的位置。
//Node pred：指代待添加节点的前一个节点。
//依据新添加的元素的位置分为两个分支：
//①新添加的元素的位置位于LinkedList最后一个元素的后面。
//②新添加的元素的位置位于LinkedList中。
    Node pred, succ;  
    if (index == size) {//在链表尾部追加数据
        succ = null;  //把succ设置为空
        pred = last;//pred指向尾节点。
    } else {
        succ = node(index);//succ指向待插入位置的节点
        pred = succ.prev; //pred指向succ节点的前一个节点
    }
    //链表批量增加，是靠for循环遍历原数组，依次执行插入节点操作。对比ArrayList是通过System.arraycopy完成批量增加的
    for (Object o : a) {//遍历要添加的节点。
        @SuppressWarnings("unchecked") E e = (E) o;
//构建新节点，新节点的prev用来存储pred节点，next设置为空
        Node newNode = new Node<>(pred, e, null);
        if (pred == null) //如果pred是空，说明是头结点
            first = newNode;
        else//若pred不为null，则将pred的next 指向新节点
            pred.next = newNode;
//步进，把pred指向当前节点，为下次添加节点做准备
        pred = newNode;
    }

    if (succ == null) {
//循环插入结束后，判断如果succ 是null，说明是在队尾添加
        last = pred; //则将pred设置尾节点
    } else {
// 否则是在队中插入的节点，
//将pred的next指向succ，succ的prev指向pred
        pred.next = succ; 
        succ.prev = pred;
    }

    size += numNew;  // 修改数量size
    modCount++;  //修改modCount
    return true;
}

3）addFirst和addLast

    public void addFirst(E e) {
        linkFirst(e);//向头部添加节点
    }
    public void addLast(E e) {
        linkLast(e);//向尾部添加节点
    }

//向头部添加节点
    private void linkFirst(E e) {
        final Node f = first;
        final Node newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

小结：
1）一定会修改modCount。
2）LinkedList批量增加，是靠for循环遍历原数组，依次执行插入节点操作。对比ArrayList是通过System.arraycopy完成批量增加。
3）通过下标index获取某个node 的时候，会根据index处于前半段还是后半段进行折半查找，以提升查询效率。

举例说明调用add函数和addAll函数后链表的状态：

　　　　List lists = new LinkedList();
　　　　lists.add(5);
　　　　lists.addAll(0, Arrays.asList(2, 3, 4, 5));

上述代码内部的链表结构如下：

3.5.2 删

remove相关方法中主要用到三个辅助方法：
unlinkFirst(Node f)：删除LinkedList中第一个节点，并且返回删除的节点的值（使用前提是f是头节点，且不能为空）。
unlinkLast(Node l)：删除LinkedList的最后一个节点，并且返回删除节点的值（该节点不为空）。
E unlink(Node x)：删除一个节点（该节点不为空）。

  private E unlinkFirst(Node f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node 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;
    }

  private E unlinkLast(Node l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node 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;
    }

    E unlink(Node x) {
        // assert x != null;
        final E element = x.item;
        final Node next = x.next;
        final Node prev = x.prev;

        if (prev == null) {
//若前置节点为null，说明x是原头节点，则将头节点指向next
            first = next;
        } else {
//否则，将x的前置节点prev的next指向x的后置节点next
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
//若后置节点为null，说明x是原尾结点，则将尾结点指向prev
            last = prev;
        } else {
//否则，将x的后置节点next的prev指向x的前置节点prev
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

1)E remove()和E removeFirst()：删除头节点，具体删除的逻辑是由unlinkFirst函数完成的。

    public E remove() {
        return removeFirst();
    }

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

2）E remove(int index)：删除指定位置节点，具体删除的逻辑是由unlink函数完成的。

public E remove(int index) {
    checkElementIndex(index);//检查是否越界 下标[0,size)
    return unlink(node(index));//从链表上删除某节点
}

    private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

3）boolean remove(Object o)：删除指定节点，具体删除的逻辑是由unlink函数完成的。

    public boolean remove(Object o) {
        if (o == null) {
            for (Node x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

4）E removeLast()：删除尾节点，具体删除的逻辑是由unlinkLast函数完成的。

    public E removeLast() {
        final Node l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

小结：一定会修改modCount。

3.5.3 改set，不修改modCount

set也是先根据index找到Node，然后替换值，改不修改modCount。

public E set(int index, E element) {
    checkElementIndex(index); //检查越界[0,size)
    Node x = node(index);//取出对应的Node
    E oldVal = x.item;//保存旧值 供返回
    x.item = element;//用新值覆盖旧值
    return oldVal;//返回旧值
}

3.5.4 查，不修改modCount

1）E get(int index)：根据index查询节点

public E get(int index) {
    checkElementIndex(index);//判断是否越界 [0,size)
    return node(index).item; //调用node()方法取出Node，并返回其值
}

2）int indexOf(Object o)：从头至尾遍历链表，根据节点查询对应下标，无此节点，则返回-1。

    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {//如果目标对象是null
        //遍历链表
            for (Node x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

3）int lastIndexOf(Object o)：从尾至头遍历链表，根据节点查询对应下标，无此节点，则返回-1。

    public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Node x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {[图片上传中...(listiterator.png-93c872-1592971851509-0)]

            for (Node x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }

4、LinkedList的迭代器

4.1ListItr内部类

private class ListItr implements ListIterator
看继承结构，发现只继承了一个ListIterator：

有向后迭代的方法，还有向前迭代的方法，所以ListItr能让linkedList向后迭代，也能让linkedList向前迭代。

ListItr中的方法表明，在迭代的过程中，ListItr还能进行移除、修改、添加值的操作。

4.2DescendingIterator内部类

这个类还是调用的ListItr，作用是封装一下Itr中几个方法，让使用者以正常的思维去写代码。例如，在从后往前遍历的时候，也是跟从前往后遍历一样，使用next等操作，而不用使用特殊的previous。

    private class DescendingIterator implements Iterator {
        private final ListItr itr = new ListItr(size());
        public boolean hasNext() {
            return itr.hasPrevious();
        }
        public E next() {
            return itr.previous();
        }
        public void remove() {
            itr.remove();
        }
    }

5、总结

1）LinkedList本质上是一个能存储null值的双向链表，通过一个Node内部类实现的这种链表结构。
2）LinkedList实现了Deque接口，能当队列使用。
3）LinkedList在删除和增加等操作上性能好，ArrayList在查询的性能上好。
4）CRUD操作里，都涉及根据index去查找Node的操作。通过下标获取某个node 的时候，会根据index处于前半段还是后半段进行折半，以提升查询效率。

6、参考笔记

Java集合源码分析（二）LinkedList
面试必备：LinkedList源码解析（JDK8）
LinkedList源码解析（基于JDK1.8）