LinkedList类的源码阅读

继ArrayList之后，我们来看一下LinkedList源码，先说一下他们实现的接口的不同之处：

相同处：

都显现了List<E>、Cloneable、java.io.Serializable其中可能不大明白的就是Cloneable接口，它是一个空接口，哪有什么作用呢，就是保证实现object中的clone方法不会报错，否则无法实现就会报错；

不同之处：

ArrayList实现了RandomAccess接口，这个也是一个空接口，它是一个标记接口，作用是使算法在随机和顺序访问list中表现的更加高效；

LinkedList则实现了Deque<E>接口，它是一个双端队列，支持两端插入元素。

所以我们看一总结出：ArrayList和LinkedList的实现结构不同，ArrayList使用的是数组实现而LinkedList则使用的链表，而且ArrayList的初始容量默认是0，这是在第一次调用add方法时进行一次10的扩容，而且在这之后它的扩容机制是下面的公式：length+length>>1这一个机制；而LinkedList是没有初始化大小和扩容机制的，添加元素直接在链表上添加即可。

接下来我们看一下LinkedList的源码，看它我们首先必须要看的是它的内部类Node<E>：

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

这个类很简单，定义了三个变量，以及一个构造函数。

prev：当前的集合。

element：要添加到集合中的元素。

next：下一个指针。

其实这里就是将一个老的node对象通过构造函数添加进去一个新的元素，组成一个新的node对象。

先看add方法：

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

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

添加元素的时候调用linkLast(E e)方法，在这个方法里面new了一个node对象，l为上一个元素，如果为空说明集合是空集合，还没往里添加数据，所以这一次添加属于第一次添加。这里要注意，这里的if判断只会走一次，而之后的每次new的时候都会借助之前的对象进行new，这样first对象的引用就一直存在新的对象中。所以使用next之后生成新的对象也是借助第一个对象进行的，所以first的值一直是在变化的。

这个方法跟addLast(E e)方法是一样的，不同的是add(E e)方法可以返回boolean的数据，而addLast(E 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++;
    }

这里的不同就是new node对象的传值不同，其他的其实都是差不多的逻辑。

我们在来看一下get方法：

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

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

这里首先有一个判断，它是判断你取值的坐标是否大于集合长度的一半，如果小于一半，就从链表集合的前面往后取，如果大于集合的一半，那就从后面取。这里就会看到一个问题，当使用for循环进行遍历取值的时候，问题是不是很严重？

它首先找到0位，然后找第二个元素的时候，他还是要先找到0位然后在获取到的对象下面找到1位元素，以此类推，当第n位元素的时候，需要[1+2+3+......+(n/2)]*2次操作；当数组大小为10时就会操作30次，即n*(n+2)/4次操作，复杂度位O(n*n），所以会很慢的。

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

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

当要添加的坐标等于集合的长度的时候，其实就是在相当于调用add(E e)方法。当其他情况的时候，我们来看一下：

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

这里的两个变量next和prev可以看做是next从链表前往后读取，而prev则是与之相反；由于这里的succ取值时，取得是大于index的值，所以要取下一个prev，而next因为是下一个，可以直接添加到最后面即可。

    public E remove() {
        return removeFirst();
    }

一看这个方法名就知道，它是移除第一个元素的方法。

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

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

可以看到，这个方法是通过first的next进行移除的，那么就是从前往后移除。