jdk集合源码之LinkedList

LinkedList不同于ArrayList，它底层使用的是双向循环链表实现的。继承自AbstractSequentialList<E>不支持随机访问，同时一个LinkedList也是一个双端队列，支持从两端的增删，双端队列在某些多线程并发的场景下有很大的作用，比如两个线程同时从头和尾取数据，不需要加锁。

要理解LinkedList的实现原理，先要认识下它的基础存储结构Entry

private transient Entry<E> header = new Entry<E>(null, null, null);
Entry(E element, Entry<E> next, Entry<E> previous) {
	    this.element = element;
	    this.next = next;
	    this.previous = previous;
	}

接收三个参数，自己节点的值，后继，前驱。

上图是一个Entry结构，也是整个LinkedList的头节点，并且它的前后指针都是自指向的。当我们创建一个默认的LinkedList的时候，头结点会自动创建出来。

/**
     * Constructs an empty list.
     */
    public LinkedList() {
        header.next = header.previous = header;
    }

看完构造函数在看看新增操作， LinkedList 的add方法默认从末尾插入，add方法调用了内部的addBefore():

private Entry<E> addBefore(E e, Entry<E> entry) {
	Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
	newEntry.previous.next = newEntry;
	newEntry.next.previous = newEntry;
	size++;
	modCount++;
	return newEntry;
    }

此处第二个参数传入的是header头结点，假设我们调用 LinkedList .add("a")，通过画图来看下整个过程：

初始只有一个header节点，该节点不存储任何数据。

addBefore首先构造了一个新的entry节点，该节点的后继指向header，前驱指向header的前驱，这里也就是header本身，如下图：

接着改变头节点前后指针的指向：

对于双向链表记住一个规则即可，如果a的前驱指向b，则b的后继需要指向a。当我们构造a的时候，a的前驱指向header的前驱（header自己），所以header.next=a(这里的header又是a.pre)-》a.pre.next=a，a的后继指向header，所以header.pre=a（这里的header又是a.next）-》a.next.pre=a，

如果再加节点b则变成下图（画图工具还不太熟练，大概能看出来意思）：

上面的新增都是在末尾新增，再来看下任意位置的新增操作：

public void add(int index, E element) {
        addBefore(element, (index==size ? header : entry(index)));
    }

初始有两个元素，a和b。注意头结点（值为null）是一个虚拟节点，对我们来说不可见，因此这个双向链表的size是2。

假设要插入的位置为1元素为c，entry(1)返回的是b这个节点，进入addBefore方法，需要把c包装成一个entry，c节点的后继指向p，前驱指向b的前驱即a，新增c后的结构如下图：

构造完新节点的指向，然后需要改变b节点的前后指针，c前驱的后继节点指向c，c后继节点的前驱指向c。如下图：

把上面的指向画直就更显而易见了，完成了任意位置的插入操作。再来看下更复杂的任意位置的批量插入，方法如下：

public boolean addAll(int index, Collection<? extends E> c) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew==0)
            return false;
	modCount++;

        Entry<E> successor = (index==size ? header : entry(index));
        Entry<E> predecessor = successor.previous;
	for (int i=0; i<numNew; i++) {
            Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
            predecessor.next = e;
            predecessor = e;
        }
        successor.previous = predecessor;

        size += numNew;
        return true;
    }

假设当前的链表状态如图：

需要插入两个新的元素c和d，插入的位置为1，即b前面，首先获取后继此处为b,获取前驱a，这里的前驱后继可以想象成是要插入集合的前驱和后继。接下来的循环操作是重点，仍然构造新节点，构造第一个节点c后的链表结构，和前面没有区别：

整个操作我们遵循的是新增节点前驱指向谁，谁的后继就得指向新增节点，所以改变a节点的后继指向c，因为后续还有节点要插入到c后面，所以c的后继先不动，而是c变成当前的前驱节点，第一层循环后变成下图：

第二层循环后：

最后，后继的前驱指向当前的predecessor，把线弄直就是下面的结构图：

新增的过程梳理完，删除的过程就显而易见了。任意位置的删除操作，假设要删除d，代码如下：

private E remove(Entry<E> e) {
	if (e == header)
	    throw new NoSuchElementException();

        E result = e.element;
	e.previous.next = e.next;
	e.next.previous = e.previous;
        e.next = e.previous = null;
        e.element = null;
	size--;
	modCount++;
        return result;
    }

d的前驱的next指针不再指向d，直接指向d的下一个节点，即d.next；d的后继的pre指针不再指向d，而是指向d的上一个节点，继d.pre，将d的前驱后继指向null，方便gc垃圾回收，如下图：

新增和删除看完后，后面的查找等操作就简单不少了，查找主要通过下面的一个方法完成：

private Entry<E> entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
    }

结合双向链表的特点，这里考虑到了性能，先判断要查找的位置离最后一个节点近还是离头结点近，分别做不同的操作。其他的一些方法没有太大的难度就不逐一去分析了。下面重点看一下迭代器的使用。这里的迭代器有两种，第一种只能从前往后迭代，第二种迭代器可以从后往前实现双向迭代。直接来看第二种迭代器ListIterator的实现，因为第一种实现其实就是第二种实现的阉割版，底层调用的都是一段代码，只是有些方法不可见了（向上转型）。 LinkedList 实现了自己的双向迭代器，并没有使用父类提供的功能。

ListItr(int index) {
	    if (index < 0 || index > size)
		throw new IndexOutOfBoundsException("Index: "+index+
						    ", Size: "+size);
	    if (index < (size >> 1)) {
		next = header.next;
		for (nextIndex=0; nextIndex<index; nextIndex++)
		    next = next.next;
	    } else {
		next = header;
		for (nextIndex=size; nextIndex>index; nextIndex--)
		    next = next.previous;
	    }
	}

主要的部分就是构造函数关于初始状态的设置，默认返回的是从头结点开始的双向迭代器，也可以指定具体的位置。整个迭代的过程主要使用nextIndex成员函数来作标记，它的位置时刻指向的当前节点的下一个节点的下标。

如果nextIndex大小等于size，则表明当前已经遍历到了最后一个节点。如果nextIndex等于0则表明已经是第一个节点了。比如初始的情况，调用next返回的是a节点，nextIndex变成1,。当第四次调用next的时候返回的是最后一个元素b，此时的nextIndex为4。