Java数据结构——LinkedList源码简介

LinkedList是Java中的数据结构之一，即链表。本篇文章将从源码角度简单介绍LinkedList的基本实现原理。

在阅读下面内容之前，请确保你已经了解链表的基本属性与特点，在此不会再做详细解释。

 

本文只介绍链表的核心操作方法，如add remove get set，其他一些不太常用的方法暂时跳过。

ArrayList之前已经介绍过：http://blog.csdn.net/daydreary/article/details/50111321

简介：

在Java中使用的LinkedList，是一个双向循环带头节点的链表。至于为什么是这样的链表，在后面可以从源码中看到。

双向：一个节点可以访问其前一个节点和后一个节点

循环：可以从头节点访问最后一个节点，也可以从最后一个节点访问头节点

带头节点：头节点不存储数据，仅表示链表的起始节点。

LinkedList类中基本属性：

private transient int size = 0;

表示存储了多少个元素，即节点个数

private transient Entry<E> header = new Entry<E>(null, null, null);

header，即头节点，是一个Entry类型的对象。

private static class Entry<E> {
	E element;
	Entry<E> next;
	Entry<E> previous;

	Entry(E element, Entry<E> next, Entry<E> previous) {
	    this.element = element;
	    this.next = next;
	    this.previous = previous;
	}
    }

Entry类中包含几个基本变量，previous，next，element

Previous：是一个Entry对象，表示当前节点的前一个节点

Next：是一个Entry对象，表示当前节点的后一个节点

Element：指定的数据对象，即此节点存储的数据

 

构造方法：

public LinkedList() {
        header.next = header.previous = header;
    }
public LinkedList(Collection<? extends E> c) {
	this();
	addAll(c);
    }

默认构造方法中将header的next,previous均指向header，header自身成环，至此已经可以看出LinkedList是一个双向循环链表

构造方法还可以将已有元素追加到链表上，add方法将在后面介绍。

 

LinkedList中最常用的方法包括：add、set、get、remove，这些方法可能有不同的参数而形成了多个重载函数。

 

add方法：

public boolean add(E e) {
	addBefore(e, header);
        return true;
    }

添加一个节点到指定位置：

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

两个方法均是调用了addBefore这个方法，其中在指定index的add方法中，传入的第二个参数是由entry方法返回的结果，其实就是进行循环查找，找到第index个节点。

 

entry方法：作用是找到第index位置，然后返回这个节点对象

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

这段代码中进行了判断，当index < (size >> 1) 时候(size>>1等价于size/2)，通过next对象向后遍历链表，因为此时index节点在链表的前半部分。否则的话，通过previous对象向前遍历链表，因为此时index节点在链表的后半部分。这样可以提高遍历的效率。

 

下面继续查看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;
    }

这个方法很简单，创建一个新的节点对象，这个新节点的next指向传入的entry，它的previous指向entry的前一节点。随后代码中修改新节点的previous.next(即entry)，指向新节点，修改其next.previous(即entry的previous)指向新节点，形成双向循环。

这样依据代码的表述可能比较抽象，下面画图解释一下这个过程：

如此新的节点被插入到entry前，形成了新的链表。

 

除了add方法外，链表也有addAll方法

public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
}

引用了addAll的另一个重载函数，插入位置是链表尾端，主要实现在这个方法中：

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

将要插入的数据转为Object数组，然后循环将元素逐个插入到指定的位置。

插入的方法，基本思路和addBefore方法一样，略有不同的地方是每次先修改了predecessor的值为新插入的节点，循环完毕后，再执行successor.previous = predecessor，使链表形成完整回路。

这样做是因为现在要插入的是很多个节点，而不是一个，每当插入一个新节点，index的位置就发生了变化，predecessor被替换为新插入的那个节点。只有最后一个新节点被插入以后，才能修改successor的previous指向位置，这样链表才能完整。

插入过程示意图：

添加的相关方法到此介绍完毕。主要核心思路就是修改节点的previous与next存放的对象，以此来形成新的完整链表。

get和set两个方法分别是对链表中的某个节点进行取值和赋值，其本质是通过entry方法实现的，entry如何实现的在之前已经介绍过。

get方法：

看下get方法源码

public E get(int index) {
        return entry(index).element;
    }

其实就是通过entry方法获取到index位置的节点，然后只要返回其中的数据即可。

 

set方法：

public E set(int index, E element) {
        Entry<E> e = entry(index);
        E oldVal = e.element;
        e.element = element;
        return oldVal;
    }

先通过entry方法获取到index位置的节点，然后修改其中的值。

 

 

remove：

remove方法即删除链表中某个节点，具体实现方法也是修改指向位置，是add的一个逆过程而已。

remove一共有3个重载函数

public E remove(int index) {
        return remove(entry(index));
    }

这是最常用的一个方法，删除index位置的节点，其实是调用了另一个重载函数。

public boolean remove(Object o) {
        if (o==null) {
            for (Entry<E> e = header.next; e != header; e = e.next) {
                if (e.element==null) {
                    remove(e);
                    return true;
                }
            }
        } else {
            for (Entry<E> e = header.next; e != header; e = e.next) {
                if (o.equals(e.element)) {
                    remove(e);
                    return true;
                }
            }
        }
        return false;
    }

这个方法是按照元素的值进行删除，循环、查找、找到这个节点后调用另一个重载函数删除掉这个节点。

remove的核心实现：

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

要删除的节点就是传入的参数e

将e的下一个节点的previous指向e的前一个节点

将e的前一个节点的next指向e的下一个节点

最后将e置为null，就可以完成删除操作了

 

删除节点操作示意图：

总结：

链表存储的数据在内存中是不连续的，通过previous和next来指向一个节点的前后节点，使得其连起来，形成完整的表结构。

由于其在内存中是连续的，所以其删除、插入操作效率很高，因为只是简单的修改previous和next的值，那么新的节点就被插入了。而ArrayList插入一个新的元素，将使得其他大量数据进行位置移动，消耗比链表高很多。

虽然删除和插入效率高，但链表的查询效率比较低，entry方法就是查询的核心，每次都要进行循环操作，虽然说根据数据位置尽量减少了循环次数，但依然不能避免本质问题。