容器源码分析之LinkedList(三)

LinkedList的构造方法

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

LinkedList实现了List、Deque接口,说明它有双端队列的特征，同时支持克隆，序列化。

我们都知道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的属性

1、LinkedList对象实例的大小

transient int size = 0;

2、头指针：指向LinkedList中的第一个元素

transient Node<E> first;

3、尾指针：指向LinkedList中的最后一个元素

transient Node<E> last;

为什么让node都防止序列化呢？很简单，如果A node序列化，那么A node的下一个节点B node也要序列化，B node序列化时，B node的上一个节点A node也要序列化，这样就陷入了无限的循环之之中，所以必须手动序列化，也就是重写readObject和writeObject，如果还是不明白，可以参考：Effective Java之考虑自定义的序列化模式(七十五)

LinkedList的构造方法

1、无参构造函数

无参构造函数，即构造一个空链表。

public LinkedList() {
    }

2、有参构造函数

public LinkedList(Collection<? extends E> c) {
        this();//调用无参构造方法构造一个空的链表
        addAll(c);
    }

这里能看出来它的ArrayList的一些不同之处，它没有默认的大小，也没有传入默认大小的参数的构造方法，构造方法相对简单。

这里有个addAll(c);不着急解释，看到后面就知道了。

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

节点链接再last节点之后，并处理了last节点可能为空的情况。如果为空，则first也应该是指向这个新节点newNode

既然上面有linkLast，LinkedList中也有linkFirst(E e),方法差不多，不再赘述。还有个方法linkBefore，插入指定位置

 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还提供了addFirst和addLast方法。如下：

public void addFirst(E e) {
        linkFirst(e);
    }

    public void addLast(E e) {
        linkLast(e);
    }

addFirst(E e)函数是借助于linkFirst来实现的，而addLast(E e)是借助于linkLast来实现的。add(int index,E element)添加到指定位置用LinkBefore

addAll方法

public boolean addAll(int index, Collection<? extends E> c) {
        checkPositionIndex(index);//索引有效性检查，即检查index>=0&&index<=size

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        Node<E> pred, succ;
        /*
            pred：用于表示即在此节点位置的后面插入新的节点
            succ：用于表示在此节点的前面位置插入节点，即插入之前此时此刻链表中的index位置的节点
            如果index==size，则在尾结点处插入
            否则：找到索引为index（从零开始）的位置节点
        */
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }
        //将所有元素加入在pre指向之后
        for (Object o : a) {
            @SuppressWarnings("unchecked") E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);//构造新的节点
            if (pred == null)//如果pred为null，则说明此时加入的为第一个结点
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
        /*
        在尾结点加入时，pred所指向的就是last的位置，
        否则，则将pred与succ的指向要进行连接起来。
        */
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;//更改链表大小
        modCount++;//增加修改次数
        return true;
    }

方法很简单，先找到index所在的节点，然后再这个节点的前面添加元素，如果这个节点的前面是空节点，那么这直接让first指向集合开头。

不知道大家都没有发现LinkedList和ArrayList不同的地方，LinkedList添加一个集合modCount只加一，ArrayList的modCount加它加上的集合的大小。

其他方法

get和set方法很简单，都是改变值的操作，相信大家不用看都应该知道怎么写，这里就不再赘述了

remove方法其实跟add方法类似，LinkedList同样封装了一个方法：unlinkFirst，unlinkLast，unlinkBefore方法，下面展示unlinkFirst方法：

   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;
        /*
        下面对next是否为空进行分支处理;
        如果为空，说明链表为空，即应该使得last=null;
        如果不为空，则将next的pre指向null。
        */
        if (next == null) 
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

remove的类似方法removeFirst,removeLast，remove(int index)，remove(Object object)其实都是调用这类封装方法。

这都是非常不错的封装，相比于ArrayList，它用链表来实现，实现的思路非常清晰易懂。