Java集合之LinkedList详解

文中源码均基于JDK1.8进行分析。

2.2 LinkedList

从集合框架图就可以看到，LinkedList既是List接口的实现也是Queue接口的实现（Deque），它可以根据索引来随机的访问集合中的元素，还实现了Deque接口，它还是一个队列，可以被当成双端队列来使用。故其和ArrayList相比LinkedList支持的功能更多。

在介绍LinkedList之前我们先复习一下有关链表的知识：
链表是由一系列非连续的节点组成的存储结构，简单分类的话，链表分为单向链表和双向链表，而单向和双向链表又可以分为循环链表和非循环链表。

1. 单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。
   

2. 单向循环链表和单向列表的不同是，最后一个节点的next不是指向null，而是指向head节点，形成一个“环”。
   

3. 双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点tail的next指向null。
   

4. 双向循环链表和双向链表的不同在于，第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。而LinkedList就是基于双向循环链表设计的。

2.2.1 LinkedList底层实现和构造函数

package java.util;
import java.util.function.Consumer;
// LinkedList由一个头节点和一个尾节点组成，分别指向链表的头部和尾部。
public class LinkedList<E> extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
   {
    transient int size = 0;//默认为0的size
    transient Node<E> first;//头结点
    transient Node<E> last;//尾节点
    public LinkedList() {
    }
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
 }

可见，LinkedList中节点Node的结构是由一个头节点，一个尾节点和一个默认为0的size构成，可见LinkedList的底层是基于双向链表实现的。其中，LinkedList中Node源码如下，由当前值item，和指向上一个节点prev和指向下个节点next的指针组成。并且只含有一个构造方法，按照(prev, item, next)这样的参数顺序构造。

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.2.2 链表的头插法和尾插法

 /**
     * Links e as first element.
     */
    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++;
    }
    /**
     * Links e as last element.
     */
    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++;
    }

2.2.3 LinkedList查询

//获取第index个节点
public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
//node(index)方法的实现
Node<E> node(int index) {
        // assert isElementIndex(index);
        // 判断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;
        }
    }  
 //checkElementIndex(index)方法：检查节点是否合法
private void checkElementIndex(int index) {
        if (!isElementIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  }
private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }

ArrayList随机访问比LinkedList快的原因: LinkedList要遍历找到该位置才能进行修改，而ArrayList是内部数组操作会更快。

//查询索引修改方法，先找到对应节点，将新的值替换掉旧的值。
public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

2.2.4 LinkedList插入和删除

//添加元素--采用尾插法将新节点放入尾部
public boolean add(E e) {
        linkLast(e);
        return true;
    }
// Links e as last element.
    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++;
    }
//删除指定节点
public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
 }
 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) {//如果前驱为null, 说明此节点为头节点
            first = next;
        } else {
            prev.next = next;//前驱结点的后继节点指向当前节点的后继节点
            x.prev = null;//当前节点的前驱置空
        }

        if (next == null) {//如果当前节点的后继节点为null ,说明此节点为尾节点
            last = prev;//当前节点的后继置空
        } else {
            next.prev = prev;//当前节点的后继节点的前驱指向当前节点的前驱节点
            x.next = null;
        }

        x.item = null;//当前节点的元素设置为null ,等待垃圾回收
        size--;
        modCount++;
        return element;
    }

2.2.5 ArrayList和LinkedList的比较

ArrayList和LinkedList均设计为非线程安全的，ArrayList内部采用的是数组，LinkedList内部采用的是链表结构。
(1)ArrayList : 采用数组保存元素，意味着当大量添加元素，数组空间不足时，依然要通过新建数组，内存复制的方式来增加容量，效率比较低，当对数组进行插入、删除操作的时候又会进行循环移位操作，效率也比较低，只有进行按照下标进行查询的首使用数组效率很高。
(2) LinkedList : 采用链表结果保存元素，在添加元素的时候只需要进行简单的一次内存分配即可，效率较高，进行插入和删除操作，只需要对链表中相邻的元素进行修改即可，效率也很高，但是进行按照下标查询时，需要链表进行遍历，效率低下。
例如：

public static void main(String[] args) {
		/**
		 * LinkedList和ArrayList中的操作是一样的
		 * 查找的时候：ArrayList效率比较高（使用频率比较高）
		 * 添加和删除：LinkedList效率比较高
		 */
		List list1=new LinkedList();
		List list2=new ArrayList();
		/*for (int i = 0; i < 5; i++) {
			list1.add(i);
		}
		System.out.println(list1.toString());
		*/
		for (int i = 0; i < 100000; i++) {
			list1.add(i);
		}
		for (int i = 0; i < 100000; i++) {
			list2.add(i);
		}	
		long start=System.currentTimeMillis();
		System.out.println(start);
		for (int i = 0; i < list2.size(); i++) {
			//System.out.println(list2.get(99899));
			list2.remove(999);
		}
		long end=System.currentTimeMillis();
		System.out.println("ArrayList所用时常："+(end-start));
		
		long start1=System.currentTimeMillis();
		for (int i = 0; i < list1.size(); i++) {
			//System.out.println(list1.get(99899));
			list1.remove(999);
		}
		long end1=System.currentTimeMillis();
		System.out.println("LinkedList所用时常："+(end1-start1));
		
		
	}