浅析Java源码之LinkedList

　　可以骂人吗？？？辛辛苦苦写了2个多小时搞到凌晨2点，点击保存草稿退回到了登录页面？？？登录成功草稿没了？？？喵喵喵？？？智障！！气！

　　很厉害，隔了30分钟，我的登录又失效了，草稿再次回滚，不客气了，***！

　　仔细想想，自动保存功能也挺可疑的，根据我半年的资深前端经验判断，内部实现大概是这样：

    var id;
　　// *core event*
    window.addEventListener('keyup',function(){
　　　　 if(id){clearTimout(id);}
        id = setTimeout(function(){
            // user would be relieved to see this...
            $('#...').html('本地自动保存于' + (new Date()).toLocaleTimeString() + ',<a href="javascript:void(0);">查看</a>')
        },1000*Math.random());
    });

　　如此智能的功能只能用这样优雅的代码实现了吧，社会社会！

　　重写。

　　上篇讲完了ArrayList，这篇继续补完LinkedList的内容。

　　首先上一张图来整体看一眼链表的结构(还好图在)：

　　每一个大方块代表一个节点(Node)，内部包含3部分内容：

1、前指针：指向上一个节点，头部元素指向null

2、数据：保存的数据内容

3、后指针：指向下一个节点，尾部元素指向null

　　Node是一个类，而且是一个私有+静态+内部类，buff齐全，看一眼实现：

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

　　非常简单暴力，3个变量，一个构造函数，没啥解释的。

　　

　　老规矩，首先从变量开始看起。

变量

public class LinkedList<E> extends AbstractSequentialList<E> implements
        List<E>, Deque<E>, Cloneable, java.io.Serializable {

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

　　3个变量，size代表当前链表长度，first与last分别指向头部与尾部节点。

构造函数

　　有两个构造函数：

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

　　其中无参构造函数啥事也不做，另外一个构造函数允许以指定集合初始化链表。

　　这里的addAll只是一个重载版本

    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

　　指向真正的addAll，在指定的位置插入链表，初始化的话size为0

    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

　　直接看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;
    }

　　函数比较长，主要分为4步：

1、索引合法性检测

2、将集合拆分为数组并检测长度，如果为0不做操作直接返回false

3、根据插入位置分情况做插入

4、插入操作

　　首先第一步，比较简单：

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

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

　　判断插入索引是否在允许范围内，抛异常。

　　第二步的插入分两种：

1、尾部插入

2、其他

　　先看尾部插入的情况，即size==index：

    succ = null;
    pred = last;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;
    }

　　在for循环中，每次都会生成一个新的Node，前指针指向pred(第一个为链表尾元素)，数据为类型转换后的集合元素。

　　然后将pred的尾指针指向新生成的节点，最后将pred置为该节点。

　　依次插入集合元素后，由于是尾部插入，所以last应该是最后插入的元素，即last=pred。

　　

　　第二种情况是中间插入，详细过程就不写了，心情有点糟糕。

方法

　　有了addAll，其他的方法就很简单了。

 getFirst/Last

    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

　　两个get方法分别返回链表的头部与尾部元素，判断是否存在并返回对应的item。

　　

remove

    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

　　两个删除方法也分别移除头部与尾部元素，方法就看一下unlinkFirst够了。

    private E unlinkFirst(Node<E> f) {
        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;
    }

　　这里将头部数据先缓存起来，然后将头部元素移除，将首元素设置为第二个节点，将第二个节点的prev置null。

　　如果第二个节点为null，说明链表中没有元素了，于是last也置null。

getIndex

　　最后看一下获取指定索引的数据

    Node<E> node(int 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;
        }
    }

　　这里不是单纯的从头遍历，而是做了一个小判断，如果索引在前半截，则从头往后遍历，否则相反。这样就将时间复杂度降低到o(n/2)，但是只有双向链表才有。

　　剩余的方法都没有什么营养，有兴趣的可以自行研究，画画图简单的很。

　　最后总结一下ArrayList与LinkedList。

1、两者都是基本的容器，可以按顺序存储元素而且不用担心容器大小

2、搜索上ArrayList由于底层是数组，所以时间复杂度为o(1)，而LinkedList为o(2/n)

3、插入元素时，ArrayList需要考虑扩容、变动索引后面元素，而链表最多只需要变动2个节点

4、虽然总体看起来ArrayList更弱，但是链表Node本身的复杂度也不容忽视，如果只为了读取还是尽量用ArrayList。