学习JDK1.8集合源码之--LinkedList

1. LinkedList简介

　　LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。因为它实现了Deque接口，所以也是双端队列的一种实现。

2.LinkedList继承关系

　　LinkedList继承自AbstractSequentialList，实现了List、Deque、Cloneable、java.io.Serializable接口。

　　1. AbstractSequentialList继承自AbstractList，是List的简化版实现，只支持按次序访问，不支持随机访问。可以被当做堆栈，队列来进行操作。

　　2. List定义了列表必实现的一些方法，如添加、删除、读取、插入、获取大小等。

　　3. Deque定义了双端队列必实现的一些方法

　　4. 实现了Cloneable接口：可以调用Object.clone方法返回该对象的浅拷贝。

　　5. 实现了 java.io.Serializable 接口：可以启用其序列化功能，能通过序列化去传输。

3. LinkedList实现

1. 核心属性

　　LinkedList底层存储是Node节点，每个节点包含了当前元素、上一个Node节点和下一个Node节点，这种双向链表的结构的好处是插入和删除都比较快，但是查找则比较慢。

　　从下面的属性可以看出，我们只知道链表首节点和尾节点的Node以及Node节点的个数，对于中间的Node则需要依次迭代才能依次获取，所以查询是很慢的。

    //实现Serilizable接口时，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。
    transient int size = 0;
    //指向首节点
    transient Node<E> first;
    //指向最后一个节点
    transient Node<E> last;

    //内部类，定义了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;
        }
    }

2. 构造函数

    public LinkedList() {
    }

    public LinkedList(Collection<? extends E> c) {
        // 调用无参构造函数
        this();
        // 添加集合中所有的元素
        addAll(c);
    }

3. 核心方法

　　LinkedList在头部和尾部对数据进行操作的时候相对来说效率会快一点，但是中间插入数据的时候，需要进行遍历，所以当数据量越大时效率越低。

　　开头插入，LinkedList比ArrayList快

　　中间插入，LinkedList比ArrayList慢

　　尾部插入，当数据量越来越大时，ArrayList比LinkedList快：当数据量大时，ArrayList每次扩容都能得到很大的新空间，解决了前期频繁扩容的劣势，而LinkedList虽然有尾指针，但是每次add都要将对象new成一个Node（而ArrayList直接数组对应位置元素赋值）

   //将节点值为e的节点作为首节点
   private void linkFirst(E e) {
        final Node<E> f = first;
        //构建一个prev值为null,next为f,节点值为e的节点
        final Node<E> newNode = new Node<>(null, e, f);
        //将newNode作为首节点
        first = newNode;
        //如果newNode后面没有节点就将newNode作为最后一个节点
        if (f == null)
            last = newNode;
        //否则就将newNode赋给其prev
        else
            f.prev = newNode;
        //列表长度加一
        size++;
        modCount++;
    }
    //将节点值为e的节点作为最后一个节点
    void linkLast(E e) {
        final Node<E> l = last;
        //构建一个prev值为l,next为null,节点值为e的节点
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
    //在非空节点succ之前插入节点e
    void linkBefore(E e, Node<E> succ) {
        final Node<E> pred = succ.prev;
        //将succ前面的节点和succ作为其prev和next
        final Node<E> newNode = new Node<>(pred, e, succ);
        //然后将newNode作为succ的prev
        succ.prev = newNode;
        //如果原来succ是首节点，则将newNode设置为首节点
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }
    //释放非空的首节点f
    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节点后面的节点设为首节点
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }
    //释放非空的尾节点l
    private E unlinkLast(Node<E> l) {
        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;
    }
    //删除非空节点x
    E unlink(Node<E> x)
    {
        final E element = x.item;
        final Node<E> next = x.next;    //x后面的节点
        final Node<E> prev = x.prev;    //x前面的节点

         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 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;
     }
     //移除首节点
     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);
     }
   //在列表首部插入节点e
     public void addFirst(E e) {
         linkFirst(e);
     }
     //在列表尾部插入节点e
     public void addLast(E e) {
         linkLast(e);
     }
    //判断列表中是否包含有元素o
     public boolean contains(Object o) {
         return indexOf(o) != -1;
     }
     //返回列表长度大小
     public int size() {
         return size;
     }
     //在列表尾部插入元素
     public boolean add(E e) {
         linkLast(e);
         return true;
     }
     //删除元素为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 {
             for (Node<E> x = first; x != null; x = x.next) {
                 if (o.equals(x.item)) {
                     unlink(x);
                     return true;
                 }
             }
         }
         return false;
     }
    //将集合c中所有元素添加到列表的尾部
     public boolean addAll(Collection<? extends E> c) {
         return addAll(size, c);
     }
    //从指定的位置index开始，将集合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;
         Node<E> pred, succ;
         if (index == size) {//说明在列表尾部插入集合元素
             succ = null;
             pred = last;
         }
         else {  //否则，找到index所在的节点
             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;
     }
     //删除列表中所有节点
     public void clear() {
         for (Node<E> x = first; x != null; )
         {
             Node<E> next = x.next;
             x.item = null;
             x.next = null;
             x.prev = null;
             x = next;
         }
         first = last = null;
         size = 0;
         modCount++;
     }
     //获取指定索引位置节点的元素值
     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;
     }
     //在指定索引位置之前插入元素e
     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));
     }
　　//返回指定索引位置的节点
　　Node<E> node(int index) {
　　　　//此处是一个小技巧，当index<size/2时，从列表前半部分开始，否则从后半部分开始
　　　　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的位置，若不存在则返回-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;
　　}
　　//逆向搜索，返回第一出现o的位置，不存在则返回-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;
　　}