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的查询性能高

 

posted @ 2017-09-28 11:31  街头小瘪三  阅读(457)  评论(0编辑  收藏  举报