JDK学习---深入理解java中的LinkedList

本文参考资料：

　1、《大话数据结构》

　2、http://blog.csdn.net/jzhf2012/article/details/8540543

　3、http://blog.csdn.net/jzhf2012/article/details/8540410

　4、http://www.cnblogs.com/ITtangtang/p/3948610.html

5、http://blog.csdn.net/zw0283/article/details/51132161

　　本来在分析完HashSet、HashMap之后，我想紧跟着分析TreeMap以及TreeSet的，但是当我读过源码以后，我就放弃了这个想法。并不是源码有多难，而是TreeMap涉及到的数据结构中的树结构，而我之前一直分析的都是线性结构，而且ArrayList、LinkedList也是线性结构，并且还没有分析。因此，我还是决定按部就班的进行，先把线性表全部分析完了，再去分析TreeMap。

　　ArrayList底层源码基本逻辑结构很简单，在《JDK学习---深入理解java中的String》一文中基本已经分析完毕，唯一不同的是String的底层数组不可变，而在ArrayList的底层Object[] 数组中，允许数组增、删、该操作，并且支持数组的动态扩容，这些东西不难，相信读者能很轻松搞明白这些知识，我就不再说明了。

　　 本文我将重点的说明一下LinkedList知识点，而LinkedList的底层是一个双向链表结构，因此我会在解析源码之前，穿插一些双向链表的知识，然后结合代码进行分析。我不喜欢很空洞的单独去说数据结构，一是因为本人水平有限说不清楚，二是因为我觉得理论需要结合代码，这样分析更加的直观一些。如果读者想要仔细的了解数据结构的知识，可以去找一些书籍详细研读。

　　

双向链表

　　《JDK学习---深入理解java中的String》一文介绍了数据结构的大体架构，《JDK学习---深入理解java中的HashMap、HashSet底层实现》介绍了线性表的单链表。

　　  本文将继续介绍数据结构的双向链表。

　　 双向链表：在单链表的每个节点中，再设置一个指向其前前驱节点的指针域 【DP】

　　 

既然是双向链表，那么对于链表中的某一个节点（p），它的后继的前驱，以及前驱的后继，其实都是这个节点本身：

p->next->prior = p = p->next-prior

　　双链表的插入操作并不复杂，但是顺序很重要，千万不能写错。

　　假设，我们现在有一个节点s，它存储的元素为e，现在要将节点s插入到节点p和p->next之间，需要严格的遵守插入的先后顺序，如下图：

s -> prior = p;                    //把p赋值给s的前驱，如图中1
s -> next = p -> next;         //把p -> next 赋值给s的后继，如图中2
p -> next -> prior = s;        //把s 赋值给 p->next的前驱 ，如图中3
p -> next =s;                    //把s 赋值给p 的后继，如图中4

关键在于它们的顺序，由于第2、3步都用到了p->next , 如果第4步先执行，则会使得p->next提前变成了s，使得插入工作完成不了。口诀是：先搞定s的前驱和后继，再搞定后继的前驱，最后解决前节点的后继。

如果插入操作理解了，那么删除操作也就简单了。

p ->prior -> next = p -> next;    //把p ->next赋值给p->prior的后继，如图中1
p ->next -> prior = p ->prior;    //把  p ->prior赋值给p ->next 的前驱，如图中2
free(p);                                     //释放节点p

　

总结：双向链表对于单链表而言，增、删操作要复杂一些，毕竟多了一个prior指针域，所以操作需要格外小心。另外，由于每个节点都需要记录两份指针，空间相对而言也占用略多一些。不过，由于它良好的对称性，使得对某个节点的增、删操作带来了方便。说白了，就是用空间换时间。

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

　　　

链表的节点插入操作：

　　说实话，当我介绍完上面的双链表信息以后，我感觉我已经把LinkedList介绍完了，因为LinkedList的底层源码确实太简单了，或者说是太规矩了，规矩到完完全全的遵守链表的插入和删除操作的思路，一点点变化都没有，甚至比使用单链表+数组实现的HashMap还要简单。可能我说再多，都不如代码来的实在，下面进行代码分析：

add(E e) 方法：

   public boolean add(E e) {
        linkLast(e);
        return true;
    }

这个方法没有逻辑判断，只是简单的调用linkLast(e)方法，下面继续跟进

 void linkLast(E e) {
        final Node<E> l = last;
　　
　　　//构造需要插入链表的节点元素，因为此方法是固定往链表尾部追加节点，因此每个将要插入的节点都不存后继节点，或者说后继节点都为null;
　　　//此处在创建节点的时候，只是制定了当前节点的前驱以及当前节点的值域，因为后继节点为null，可以不指定后继指针域
        final Node<E> newNode = new Node<>(l, e, null);

　　　　　
        last = newNode;
　　　　//此处判断第一个节点是否存在，不存在的话直接将当前节点指定为头节点。如果存在，则将当前将要插入的节点指定给前一个节点的后继。因此是追加，这里可以省略当前节点的后继节点持有当前节点的指针
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

add(int index, E element)方法：这个方法算能够体现出双链表节点的插入功能。

  public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
　　　　　　　//这个地方在上面的方法已经分析过了，比较特殊，就不再次分析了
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

　　

接下来跟进到linkBefore(element, node(index))方法中:

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

我们假设这个链表很长，我们正常的在中间插入一个节点，也就是正常的双向链表节点插入功能。还记得口诀吗？口诀是：先搞定s的前驱和后继，再搞定后继的前驱，最后解决前节点的后继。 

下面根据口诀，我们对linkBefore(E e, Node<E> succ)进行解析:  succ节点现在的位置，就是我们需要插入的位置，也就是说要在succ节点和它的前一个节点succ->prev中间插入当前节点信息E e。

先搞定s的前驱和后继，此通过final Node<E> newNode = new Node<>(pred, e, succ)生成的newNode不就相当于之前口诀中的s吗，而且pred和succ不就是s的前驱和后继嘛。

再搞定后继的前驱，最后解决前节点的后继   ： 此处不就是通过上面的succ.prev = newNode;  以及 后面的 pred.next = newNode; 来完成的嘛。

再次强调，这样分析，上面的黄色字体已经进行了假设了，即：这个链表很长，我们正常的在中间插入一个节点，也就是正常的双向链表节点插入功能

链表的节点替换set(int index, E element) 方法：这个方法比较简单

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

链表的节点删除remove(Object o)方法：

public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
　　　　　　  //我想说明这个分支，因为链表的节点删除，肯定是要模拟正常的情况，Object o这个参数正常存在
　　　　　　　//在这个地方，我也是有疑问的。如果链表长度为1000，而我们的o放在第998的位置上，如果是这样的话，for需要迭代998次，我完全看不出来它的删除性能高在哪里。如果非要说性能高，
　　　　　　　//那只能勉强说还是节省了移动节点的时间吧
　　　　　　　　 for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

看完这个方法，好像并没有直接操作链表，下面看看unlink(Object)方法：

 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的查询方法：

get(int index)方法：

 public E get(int index) {
　　　　 //此处是判断给定的index下标是否合法
        checkElementIndex(index);
　　　　
        return node(index).item;
    }

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

仔细分析一下此方法，无论是if分支，还是else分支，都涉及到了for循环进行迭代，直至找到满足条件的index位置为止，这样的话如果数据量比较大，性能肯定会比较低下。而ArrayList则是直接从底层数组中拿，不需要做任何的遍历，性能明显高很多。

再看看Iterator()方法：

  public Iterator<E> iterator() {
        return listIterator();
    }

跟进：

  public ListIterator<E> listIterator() {
        return listIterator(0);
    }

再跟进：

    public ListIterator<E> listIterator(final int index) {
        rangeCheckForAdd(index);

        return new ListItr(index);
    }

继续跟进ListItr类：

private class ListItr extends Itr implements ListIterator<E> {

继续跟进Itr：

        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

最终我们发现，如果要是对LinkedList类进行迭代，最终还是调用的get()方法，而这个方法我们在上面已经分析过了，性能比ArrayList的get方法要低很多，因此LinkedList的Iterator（）方法性能不高。

总结：

　　1、通过代码我们看到，所有的插入方法，替换方法以及删除方法，都是直接对节点的前驱与后继进行直接操作，根本没有涉及到移动节点让出位置的情况，这个比线性表的顺序存储结构性能要高；不过需要说明的是，链表的性能要体现在数据量上面，比如我们总共就10个节点元素，那么使用ArrayList与LinkedList的性能可能根本没有区别。

　　2、查询方面：ArrayList的get方法是直接到底层数组中去拿值，而LinkedList的get方法则每次都需要对链表进行遍历，尽管遍历的过程中已经采用了算法进行优化，但是效率依旧还是很低。

　　3、ArrayList的iterator底层依旧是自己的get（）方法，而LinkedList的iterator方法底层也是自己的get()方法。而ArrayList的get方法性能比LinkedList的get方法性能高，因此，ArrayList的Iterator方法比LinkedList的iterator方法性能要高。整体来说，ArrayList的查询性能就是比LinkedList的查询性能高