码迷,mamicode.com
首页 > 编程语言 > 详细

【Java集合】试读LinkedList源码

时间:2017-07-27 00:55:32      阅读:234      评论:0      收藏:0      [点我收藏+]

标签:logs   输入   ++   try   equals   exception   详细   引用   etl   

技术分享

 

LinkedList的本质是双向链表。
(01) LinkedList继承于AbstractSequentialList,并且实现了Dequeue接口。 
(02) LinkedList包含两个重要的成员:header 和 size
  header是双向链表的表头,它是双向链表节点所对应的类Entry的实例。Entry中包含成员变量: previous, next, element。其中,previous是该节点的上一个节点,next是该节点的下一个节点,element是该节点所包含的值。 
  size是双向链表中节点的个数。

(前面照旧是复制粘贴的图和文字,大家大概理解一下,下面进入正题)

为了理解上面的概念,首先我们来看一下核心类Node

 

//节点,有前驱,后继和值三个字端,其中前驱和后继也是节点
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表示的是结点,结点里面有三个元素:

数据,前驱和后继。

其中数据可是任意类型,前驱和后继同样是结点。

我们可以想象一个双向链表依次一共有A,B,C三个结点,他们的数据分别为a,b,c。那么:

A的前驱为null,后继为B,数据为a。

B的前驱为A,后继为C,数据为b。

C的前驱为B,后继为null,数据为c。

 

接下来我们来看一下构造函数和类变量

    //集合元素个数
    transient int size = 0;

    //第一个节点
    transient Node<E> first;

    //最后一个节点
    transient Node<E> last;

    //输入为空的构造函数
    public LinkedList() {
    }

    //直接传入一个Collection放入LinkedList中的构造器,
    public LinkedList(Collection<? extends E> c) {
        //调用无参的构造期
        this();
        addAll(c);
    }

 

类变量分别是List中数据的个数,第一个结点和最后一个结点。

构造函数有两个:一个是空的构造函数,一个是传入一个Collection来生成LinkedList。

我们来具体看一下这个addAll方法

 //将指定集合c中所有的元素,按照其迭代器返回的顺序全部追加到集合的结尾。
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

    //将指定集合c中所有的元素,按照其迭代器返回的顺序全部追加到集合的特定位置。
    public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;
        //pred是predecessor前置节点,succ是succeed 后置节点,请大家学好英语(笑)
        Node<E> pred, succ;
        if (index == size) {
            //新增节点在最后一个
            succ = null;
            pred = last;
        } else {
            //新增结点在index处
            succ = node(index);
            pred = succ.prev;
        }
        //前驱节点不为null的情况下,循环生成新节点,把前任节点作为新节点的前驱,数组里的数作为节点的值,后继置为空
        //然后把新节点作为前驱的后继,之后把新节点作为前驱,继续循环执行
        //可能你这个时候会有疑问,那不是没有制定后继?并不是的,后继是在你的新节点变为前驱后,由 pred.next = newNode;这一句指定的。
        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;
        }
        //后继为空,则最后一个就是前驱(也就是前面最后一句指定为前驱的newNode)
        //后继不为空的话,则把后继作为前驱(就是前面最后一句指定为前驱的newNode)的后继,前驱作为后继的前驱
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
        //列表里的数增加
        size += numNew;
        //这个用来判断迭代器的fast-fail的,具体见我的前一篇ArrayList的那篇博文
        modCount++;
        return true;
     }

整个把Collection变为LinkedList的过程写的比较详细了,不再赘述。

 

现在我们随便看一些常用的方法,比如说获取第一个结点的值,我们发现会有getFirst()和peekFirst()这样两个方法;同样的获取最后一个结点的值,我们发现会有getLast()和peekLast()两个方法。那么为何会有两种呢?

我们看一下源码:

//获取第一个结点的值
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

//获取的第一个结点的值
    public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
 }

我们可以看出来,前者如果结点为空会报错,后者如果结点为空则会返回null。

以下对第一个结点和最后一个结点的操作:

 

        第一个结点(头部)                 最后一个结点(尾部)
        抛出异常        特殊值            抛出异常        特殊值
插入    addFirst(e)    offerFirst(e)    addLast(e)      offerLast(e)
移除    removeFirst()  pollFirst()      removeLast()    pollLast()
检查    getFirst()     peekFirst()      getLast()        peekLast()

 

左边的操作遇到异常会抛出异常,右边的操作遇到异常会返回特殊值。

 

由于LinkedLIst分别实现了队列和栈的接口,以下也是对第一个结点和最后一个结点的操作

当作为队列时,下表的方法等价:

 
队列方法       等效方法
add(e)        addLast(e)
offer(e)      offerLast(e)
remove()      removeFirst()
poll()        pollFirst()
element()     getFirst()
peek()        peekFirst()
 

当作为栈时下表的方法等价:

栈方法        等效方法
push(e)      addFirst(e)
pop()        removeFirst()
peek()       peekFirst()

 

以上说的都是对第一个结点和最后一个结点的操作,接下来写一下对中间结点的操作:

 //返回特定位置的结点的值
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    //替换特定位置的结点的值,返回旧的值
    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

    //替换特定位置的结点,原结点向后移
    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

    //删除特定位置的结点
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

 

里面的具体操作如下:

 

   //获取某个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;
        }
    }

//把输入的数e作为新增在最前面的结点的值
    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++;
    }

    //把输入的数e作为新增在最后面的结点的值
    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++;
    }

    //把输入的数e作为新增在结点succ的前面的结点的值
    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++;
    }

    //把非空的LinkedList的第一个节点unlinked(删除)
    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;
    }

    //把非空的LinkedList的最后一个节点unlinked(删除)
    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;
    }

    ///把非空的LinkedList的某个节点unlinked(删除)
    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;
    }

 可以从上面看出来新增和删除元素都是比较方便的。

 

还有两个比较特殊的删除方法:

    //删除第一个出现的特定值
    public boolean removeFirstOccurrence(Object o) {
        return remove(o);
    }

    //删除最后一个出现的特定值
    public boolean removeLastOccurrence(Object o) {
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

它们的特殊之处在于,它们想要删除的结点的数值也许有很多个,但是它们只会删除第一个出现的或者是最后一个出现的。

 

 

 

然后我们看一下搜索元素的方法:

   //判断是否包含某个特定的结点的值
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

//查找LinkedList中是否包含某个值,并返回第一个出现这个值的索引值,否则返回-1
    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

    //反向查找LinkedList中是否包含某个值,并返回第一个出现这个值的索引值,否则返回-1
    public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }

可以看出来,搜索元素是比较麻烦的,必须要全部遍历一遍。

 

 最后我们看一下一些边界值判断的方法:

    //判断某个索引值是否存在
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

    //判断这个索引是否超出了位置的边界,这个和上面的有何区别?为何index是<=而不是<
private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    //多种边界异常的判断
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

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

    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

 

限于篇幅(Lan),其他方法就不一一介绍了。

 

总结

1.LinkedList的本质基于双向链表实。

2.LinkedList在查找元素时,必须遍历链表;在新增和删除元素时,只要调整前后的引用就可以了。

3.LinkedList不是线程安全的,同样拥有fast-fail机制。

 

【Java集合】试读LinkedList源码

标签:logs   输入   ++   try   equals   exception   详细   引用   etl   

原文地址:http://www.cnblogs.com/jing-daye/p/7242576.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!