【Java集合】LinkedList源码解析

LinkedList简介

LinkedList是基于双向循环链表实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。当然同时也具备了链表的特性：插入和删除元素效率高。

LinkedList同样也是非线程安全的，只在单线程下适合使用。

同时实现了Serializable接口，因此支持序列化，能够通过序列化传输；实现了Cloneable接口，能被克隆。

源码分析

核心实现就是通过双向循环链表来对元素进行存储操作。

具体是怎么实现的，通过源代码来看一下。

主要的成员变量：

	//linkedList中元素个数
    transient int size = 0;
    //用来表示LinkedList的头节点
    transient Node<E> first;
    //用来表示LinkedList的尾节点
    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;
        }

我们可以看到，核心就是用来存储LinkedList元素的数据结构的Node内部类，具有前节点和后节点的双向链表结构。

再来看看构造函数：

构造函数：

构造函数有两种构造方式，第一种是默认构造函数：创建一个空的链表；第二种是创建一个包含Collection集合的LinkedList。

因为是基于链表实现，所以不存在扩容的问题。

    public LinkedList() {
    }

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

主要的方法：

添加数据有add和addAll两种方式：add方法就是在链表的最后添加一个元素；addAll方法从双向链表的末尾开始，将集合c添加到LinkedList。

    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    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;
		// pred当前要插入元素位置的前一个节点，succ当前要插入元素位置的后一个节点
        Node<E> pred, succ;
        //如果直接在链表尾添加，将前节点设置为原链表last节点，后节点设置为null
        //如果不是，则是在原链表中间插入一个元素，node方法返回对应索引位置上的Node（节点）。pred指向succ节点的前一个节点
        if (index == size) {
            succ = null;
            pred = last;
        } else {
            succ = node(index);
            pred = succ.prev;
        }
		//遍历数组，插入元素，在每次遍历的时候，都新建一个节点Node
        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;
        }
		//调整LinkedList的实际大小
        size += numNew;
        modCount++;
        return true;
    }

关于链表，如果我们要查询指定位置的元素，因为链表没有下标和索引，所以需要遍历整个链表，源码是怎么实现的呢？

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

核心就在于node方法，可以看到，源码里面先将index于size长度的一半比较，如果大于size/2，只需要从从位置size往前遍历到位置size处，反之，则从0开始遍历到size。这样可以减少一些不必要的操作，从而提高一定的效率。

其他的方法不再赘述，其实本质上都是关于链表的操作，如果熟悉链表的同学，应该是so easy的，不熟悉的同学需要重新好好复习一下关于链表的操作。

思考

关于LinkedList源码，比较重要的几点：

1. 从源码很容易看出来，LinkedList的实现是基于双向循环链表的；
2. 两个构造方法。无参构造方法建立了一个空链表，包含Collection的构造方法，先调用无参构造方法建立了一个空链表，而后再讲Collection的元素加入到链表的尾部后面；
3. 查找和删除元素时，源码都划分了元素为null和不为null的情况，LinkedList允许元素null；
4. LinkedList基于链表实现，因此不存在容量不足的问题；
5. 链表是没有下标索引的，要获取指定位置的元素，就得遍历该链表，虽然源码用了一定的加速，但效率依旧不高；
6. LinkedList基于链表实现，所以插入删除效率高，查询效率低。
7. 源码中还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用。

相关文章：【Java集合】ArrayList源码解析。