【预习笔记】读几个Java集合类源代码—LinkedList

说实话第一次读到LinkedList的代码我是被惊到了的，因为JDK里的LinkedList竟然是存在前驱指针的.....

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    private transient Entry<E> header = new Entry<E>(null, null, null);
    private transient int size = 0;

    /**
     * Constructs an empty list.
     */
    public LinkedList() {
        header.next = header.previous = 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;
	}
    }

remove方法，以对象作为参数：

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

可以看到，如果链表中是存在等值的，那么链表在删除掉第一个节点之后就会返回true了。

remove方法是以boolean类型作为返回值的。内部调用的remove方法以Entry节点作为参数传入，先变动待删除节点的前驱节点的后继节点，再变动待删结点的后继节点的前驱节点。

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

添加节点的时候调用Entry的构造方法完成一半的任务，然后在本方法内部再完成一半的任务。

如果以某个索引位置作为参数传入，需要从头开始遍历链表。找到第index位置然后调用add方法。

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