LinkedList源码解析

概念

基于双端链表的List，Deque接口实现。具有链表的高效添加、删除，但查找性能比较低下，需要从头到尾或者从尾到头遍历链表。

源码解析

源码解析只涉及到一些核心功能实现分析，不会对LinkedList的所有源码进行展开。

字段属性

// List容量大小
transient int size = 0;
// 首节点
transient Node<E> first;
// 尾节点
transient Node<E> last;

双链表节点结构

使用内部类Node来定义链表的节点

 // 使用泛型来存储数据Item
 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的源码实现，不外乎是双端链表的实现过程，因此通过List接口的add,remove,get等方法来对双端链表的实现一探究竟。

add

// 将指定元素添加到此列表的结尾
public boolean add(E e) {
    linkLast(e);
    return true;
}
// 构建节点添加到双端链表的尾部
void linkLast(E e) {
	// 尾节点
    final Node<E> l = last;
	// 构建一个新的节点，其前驱节点指向原来的尾节点，后继节点为null
    final Node<E> newNode = new Node<>(l, e, null);
	// 更新尾节点为新建节点
    last = newNode;
	// 如果链表为空
    if (l == null)
		// 将首节点指向新建节点
        first = newNode;
    else
		// 尾节点的后继节点指向新建节点
        l.next = newNode;
	// 数量加1
    size++;
    modCount++;
}

// 在此列表中指定的位置插入指定的元素。
public void add(int index, E element) {
    checkPositionIndex(index);
	// 如果是插入到列表尾部使用linkLast方法
    if (index == size)
        linkLast(element);
    else
		// 先使用node查找index位置的节点，将元素插入到index节点前面
        linkBefore(element, node(index));
}
// 在指定结点succ前插入元素
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
	// succ节点的前驱节点
    final Node<E> pred = succ.prev;
	// 构建新节点，节点的前继和后继指向succ的前继和succ
    final Node<E> newNode = new Node<>(pred, e, succ);
	// succ的前继指向新结点
    succ.prev = newNode;
	// 如果succ是首节点，则头节点指向新建节点。否则succ前继节点的后继指向新建结点。
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
	// 数量加1
    size++;
    modCount++;
}

remove

// 获取并移除此列表的头（第一个元素）。
public E remove() {
    return removeFirst();
}
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}
//删除首节点
E unlinkFirst(Node<E> f) {
		assert f == first && f != null;
		// 首节点元素。
		final E element = f.item;
		// 首节点的后继节点
		Node<E> next = f.next;
		// help gc
		f.item = null;
		f.next = null;
		// 首结点变成首节点的后继节点。
		first = next;
		// 列表只有一个元素，尾节点置null
		if (next == null) {
			last = null;
		} else {
			// 首节点的前驱节点置null
			next.prev = null;
		}
		size--;
		return element;
		
}
// 获取并移除此列表的尾（最后一个元素）。
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}
// 删除尾结点
E unlinkLast(Node<E> l) {
		assert l == last && l != null;
		final E element = l.item;
		// 尾节点的前驱节点
		final Node<E> prev = l.prev;
		// help gc.
		l.item = null;
		l.prev = null;
		// 尾节点变成前一个节点。
		last = prev;
		// 列表只有一个元素，首节点置null
		if (prev == null) {
			first = null;
		} else {
			// 尾节点的后继驱节点置null
			prev.next = null;
		}
		size--;
		return element;
}	
// 移除此列表中指定位置处的元素
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}		
// 删除指定节点
E unlink(Node<E> x) {
		assert x != null;
		// 待删节点元素
		final E element = x.item;
		// 待删节点前继和后继节点
		Node<E> pred = x.prev;
		Node<E> succ = x.next;
		// help gc.
		x.item = null;
		x.prev = null;
		x.next = null;
		// 如果删除的节点是首节点，则首节点设置成后继节点。否则前继结点的后继指向后继结点。
		if (pred == null) {
			first = succ;
		} else {
			pred.next = succ;
		}
		// 如果删除的节点是尾结点，则尾节点设置成前继节点。否则后继节点的前继指向前继节点。
		if (succ == null) {
			last = pred;
		} else {
			succ.prev = pred;
		}
		size--;
		return element;
}

get

// 返回此列表中指定位置处的元素。
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
// 查找指定下标节点
Node<E> node(int 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;
		}		
}