Java集合之LinkedList

LinkedList 实现了List接口和Deque接口，是一个双向链表，和ArrayList不一样，它占有的是一段分散的空间。其基础元素为Node，Node包含了三个属性：prev, item, next。其中prev指的是当前Node的前一个Node，item是指当前Node的内容，next是指当前Node的下一个Node，由这种方式将一个个Node关联起来，形成一个双向链表。
如下图，Node_A的prev为空，next为Node_B，Node_B的prev为Node_A，next为Node_C，对于Node_C，next为空，prev为Node_B。我们在建立新的Node时，需要注意到头节点和尾节点，并且设置好相应的prev和next。

由上图可见，如果需要在LinkedList中插入一个新的Node，需要注意以下几点：
1. 设置好要插入的位置的前节点 prevNode的next
2. 设置好要插入的位置的后节点 nextNode的prev
3. 设置好要插入的节点prev和next。
4. 考虑到插入完这个元素后，它是否会成为first或者last节点。

常用方法：

• linkedBefore(Element e, Node node)
  此方法的目的是将e元素形成的节点插入到node之前。
  源码如下：

    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        //拿到succ的前一个，为了改它的next
        final Node<E> pred = succ.prev;
        //将元素e形成新Node，把succ的前节点偷来当作自己的前节点，将succ当作自己的后节点，因为它要插在这两个中间，这样新节点算是设置完了
        final Node<E> newNode = new Node<>(pred, e, succ);
        //设置succ节点，它的前节点变了
        succ.prev = newNode;
        if (pred == null)
             //考虑新节点是不是插到了最前面
            first = newNode;
        else
            //若新节点不是头节点，需要将它设置为succ.prev.next,也就是pred的后一个节点
            pred.next = newNode;
        //加了一个新节点，size要变大一号
        size++;
        //结构变了，modCount也加一
        modCount++;
    }  

• unlink(Node node)
  此方法的目的是将node移出当前链表。
  源码如下：

    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 {
            //把当前节点的前节点的next设置为当前节点的后节点
            prev.next = next;
            //自断筋骨，把当前节点的前节点置空
            x.prev = null;
        }

        if (next == null) {
            //如果当前节点是尾节点，那么移掉之后尾节点要变化。
            last = prev;
        } else {
            //把当前节点的后节点的prev设置为当前节点的前节点
            next.prev = prev;
            //自断筋骨，把当前节点的后节点置空
            x.next = null;
        }
        //内容置空
        x.item = null;
        //移掉一个Node，size减小一个
        size--;
        //结构改变，modCount加一
        modCount++;
        return element;
    }

• get(int index)
  此方法的目的是按照给出的index获取当前链表的某个Node。
  源码如下：

public E get(int index) {
    //确认这个index是否合法/有效
        checkElementIndex(index);
        //获取Node的内容
        return node(index).item;
    }    
private void checkElementIndex(int index) {
    //index不合法就报错
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
private boolean isElementIndex(int index) {
    //index需要在size内并且不为负数
        return index >= 0 && index < size;
    }
Node<E> node(int index) {
        // assert isElementIndex(index);
    //size >> 1相当于size/2
        if (index < (size >> 1)) {
            //经判断，这个node在前半段，由first开始查找
            Node<E> x = first;
             //从first的next指针得到第二个，相继得到第三个，第四个，第index个，返回相应的node
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
             //经判断，这个node在后半段，由last开始查找
            Node<E> x = last;
            //从last的prev指针得到第倒数二个，相继得到倒数第三个，第四个，第index个，返回相应的node
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

由此可见，你的index如果是index/2+1或者是index/2-1，那么这个查找的速度会慢到极致，这个时候就比较推荐用LinkedList的好基友－ArrayList。

• 对头节点的操作：
  peek() 返回头节点包含的元素E
  pop() 删除头节点并且返回其元素E
  poll() 在我看来和pop很相似
  push(Element e) 将e形成的节点插到最前面

注意：LinkedList不是线程安全的类