集合源码阅读（三）：基于jdk12的LinkedList源码分析

一、前言

LinkedList是Java集合框架中一个重要的实现，底层采用双向链表结构。和ArrayList一样，其也支持null值和重复值。它基于双向链表实现，就不用扩容了，可这也就是说，在维护结点的时候需要额外的空间存储前驱和后继的引用。在链表头部和尾部插入效率比较高，但是在指定位置插入就不太行了，原因是定位需要O（N）的时间复杂度，这也就是说查找的效率也不太行。最后，他是非线程安全集合类。这篇文章会写一些LinkedList底层重要的方法。

二、源码阅读部分

1.声明部分：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

可以看出它继承了AbstractSequentialList，查看AbstractSequentialList的源码，发现里面实现了增删查，很多都是基于iterator实现的。不用LinkedList自己重新实现了其中的一套方法，此外说一点，一般建议声明明队列的时候：Queue<T> queue = new LinkedList<>(); 而且建议用LinkedList实现Stack。因为原生的Stack<T> stack = new Stack<>();有很多问题。

---

2.get方法：

public E get(int index) {
    //检查index是否合理
    checkElementIndex(index);
    return node(index).item;
}
Node<E> node(int index) {
    // assert isElementIndex(index);
    // 如果index是小于size的二分之一，这设计的很巧妙
    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;
    }
}

---

3.add方法：

//单参，在链表尾部插入元素
public boolean add(E e) {
    linkLast(e);
    return true;
}
//双参，在指定位置加入元素
public void add(int index, E element) {
    //老规矩先检查
    checkPositionIndex(index);
    //如果index就是size，就直接在末尾加
    if (index == size)
    	linkLast(element);
    //否则在指定位置之前插
    else
    	linkBefore(element, node(index));
}
/**
 * Links e as last element.
 * 将e插入最后一位
 */
void linkLast(E e) {
    final Node<E> l = last;
    //初始化新结点，指明前驱为l，后继为null
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    //如果链表为空，就直接插第一个
    if (l == null)
    	first = newNode;
    //前面把last给l了，则直接把新插入的元素插到l的后面
    else
    	l.next = newNode;
    //改变了原有数据结构，操作数加一
    size++;
    modCount++;
}

/**
 * Inserts element e before non-null Node succ.
 * 在非空结点之前插入e
 */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    //前提就是当前结点不空
    final Node<E> pred = succ.prev;
    //初始化新结点，指明前驱为pred，后继为当前结点succ
    final Node<E> newNode = new Node<>(pred, e, succ);
    //让succ的前驱指向新结点
    succ.prev = newNode;
    //如果pred为空，表明当前元素是第一个元素，或者当前链表为空
    if (pred == null)
    	first = newNode;
    //否则，succ的前驱的后继变成了新加入的结点
    else
    	pred.next = newNode;
    //改变了原有数据结构，操作数加一
    size++;
    modCount++;
}

按照索引插入的过程大概就是：

1. 创建新结点，并指明新结点的前驱和后继
2. 将succ的前驱引用指向新结点
3. 如果succ的前驱不空，则将succ的前驱的后继指向新结点

---

4.remove方法：

public boolean remove(Object o) {
    //前面说过，LinkedList里面是可以塞空的，所以这就先在里面找null，从前往后，只要找到第一个就删
    if (o == null) {
    	for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
            	unlink(x);
            	return true;
            }
    	}
    } else {
    	//否则就是找元素，找到就删
    	for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
            	unlink(x);
            	return true;
            }
    	}
    }
    return false;
}
//解除链接
E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
    
    //prev为null表示x第一个元素，直接让first指向x的后继就行
    if (prev == null) {
    	first = next;
    } else {
    	//否则就是x前驱的后继直接赋给x的后继，并让x的前驱引用为null，即释放x与前驱的连接
    	prev.next = next;
    	x.prev = null;
    }
    //next为null表示x为最后一个元素，直接让last指向x的前驱就行
    if (next == null) {
    	last = prev;
    } else {
    	//否则就是x后继的前驱直接赋给x的前驱，并让x的后继引用为null，即释放x与后继的连接
    	next.prev = prev;
    	x.next = null;
    }
    //清除x的数据，方便GC回收
    x.item = null;
    //改变数据结构
    size--;
    modCount++;
    return element;
}

删除的时候断开连接的步骤小结（假设x既不是头也不是尾）：

1. 将待删除结点x的前驱的后继指向x的后继
2. 将x的前驱引用置空，断开x与前驱的连接
3. 将待删除结点x的后继的前驱指向x的前驱
4. 将x的后继引用置空，断开x与后继的连接

---

三、写在最后

最后在讲一下基于LinkedList实现的Queue里面的一些常用方法，方便后续学习：

查看Queue接口，里面有这些方法：

在队尾增加元素：boolean add(E e);

在队尾增加元素：boolean offer(E e); //这个元素内部就是调用add方法，不再赘述

删除元素：

E remove();
//这个是Queue特有的remove
public E remove() {
    return removeFirst();
}
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
    	throw new NoSuchElementException();
    return unlinkFirst(f);
}

出队并取得之：E poll();

//出队并且取得队首操作
public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

取得队首元素：E element();

取得队首元素：E peek();

public E peek() {
    //和上面的区别就是这个peek可以在队空的情况下返回null，上面element()则直接报异常
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}