LinkedList 学习

底层实现： LinkedList 基于双向链表实现
线程安全：LinkedList 线程不安全
优点：LinkedList 基于链表，插入删除快，但读取较慢
缺点：线程不安全，读取慢

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由三部分组成，本身值，前一个Node和后一个Node，这三个值之间的关系由图可见，prev链接的是前一个节点的内容，next链接的是后一个节点的内容。如果后一个节点不存在，则指向null

LinkedList 的成员变量

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

LinkedList只包含三个成员变量，分别为大小size，前一个节点first和后一个节点last

LinkedList的构造器

public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

LinkedList有两个构造器，一个为无参构造器，一个为传入Collection集合的构造器。
在传入Collection构造器的时候，调用addAll(） 方法

addAll() 方法

public boolean addAll(int index, Collection<? extends E> c) {
    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);
        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;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

添加时，需要先判断下标是否正常。
然后分别将index所对应的Node的prev和next设置为对应的Node的值。
由于采用了链表结构，每次插入一个Node(调用add方法)的时间复杂度为
不指定index(直接加在末尾)： O(1)
指定index： O(n)

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

在链表的末尾插入一个值

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;
    if (next == null)
        last = null;
    else
        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;
    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 = 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中的addFirst(), addLast(), removeFirst(), removeLast() 等等方法都是基于上述几个私有方法完成的

node(index)方法

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

根据下标找到指定的值。
首先会做一个除以2的操作，如果index小于size的1/2， 那么从前往后找，反之，如果index大于size的1/2，那么从后往前找。

peek() 与 pool() 的区别

public E peek() {
   final Node<E> f = first;
    return (f == null) ? null : f.item;
}
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

这两者的区别在于，peek() 不会删除LinkedList的数据，但poll() 会删除LinkedList中的数据。

push() 和 pop()

public void push(E e) {
   addFirst(e);
}
public E pop() {
    return removeFirst();
}

push() 是再链表头部添加数据，pop() 是从链表头部取出数据

结尾：
LinkedList不同于ArrayList，ArrayList基于动态数组实现，插入前需要判断数组长度是否充足，在不充足的情况下还需要进行扩容，且数组的长度还受到VM的限制，并不是可以无限插入数据。而LinkedList是基于双向链表结构，无需扩容，且理论上长度也没有限制。
LinkedList的代码很大一部分都是去实现了双向链表数据结构的功能，比如添加删除查找等，可见：数据结构虽说在明面上用不到，但底层全是。还是有必要好好学习数据结构和算法的。