Article Directory
Outline
LinkedList frame is an important set of Java implementation, the underlying structure of the doubly linked list used. And, like ArrayList, LinkedList also supports null values and duplicate values. Because LinkedList list based implementation, storage elements in the process, without the need for expansion as like ArrayList. But gains will lose, LinkedList node storage elements need extra space to store the precursor and subsequent references. On the other hand, head and tail of the list in the LinkedList insert more efficient, but at the specified insertion position, the general efficiency. The reason is that, at the specified position needs to be positioned to the node is inserted at the location, time complexity of this operation O(N). Finally, LinkedList non-thread-safe collection classes, concurrent environment, multiple threads operating LinkedList, will lead to unpredictable errors.
The above is a brief introduction to LinkedList, then, I will expand the analysis of the LinkedList common operations, continue to read on.
Inheritance system
LinkedList inheritance system is more complex, inherited from AbstractSequentialList, while achieving List and Deque interfaces. Inheritance system is shown below (delete the partial implementation of the interface):
LinkedList 继承自 AbstractSequentialList，AbstractSequentialList 又是什么呢？从实现上，AbstractSequentialList 提供了一套基于顺序访问的接口。通过继承此类，子类仅需实现部分代码即可拥有完整的一套访问某种序列表（比如链表）的接口。深入源码，AbstractSequentialList 提供的方法基本上都是通过 ListIterator 实现的，比如：
public E get(int index) {
try {
return listIterator(index).next();
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
public void add(int index, E element) {
try {
listIterator(index).add(element);
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
// 留给子类实现
public abstract ListIterator<E> listIterator(int index);
所以只要继承类实现了 listIterator 方法，它不需要再额外实现什么即可使用。对于随机访问集合类一般建议继承 AbstractList 而不是 AbstractSequentialList。LinkedList 和其父类一样，也是基于顺序访问。所以 LinkedList 继承了 AbstractSequentialList，但 LinkedList 并没有直接使用父类的方法，而是重新实现了一套的方法。
另外，LinkedList 还实现了 Deque (double ended queue)，Deque 又继承自 Queue 接口。这样 LinkedList 就具备了队列的功能。比如，我们可以这样使用：
Queue<T> queue = new LinkedList<>();
除此之外，我们基于 LinkedList 还可以实现一些其他的数据结构，比如栈，以此来替换 Java 集合框架中的 Stack 类（该类实现的不好，《Java 编程思想》一书的作者也对此类进行了吐槽）。
关于 LinkedList 继承体系先说到这，下面进入源码分析部分。
源码分析
查找
LinkedList 底层基于链表结构，无法向 ArrayList 那样随机访问指定位置的元素。LinkedList 查找过程要稍麻烦一些，需要从链表头结点（或尾节点）向后查找，时间复杂度为 O(N)。相关源码如下：
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node<E> node(int index) {
/*
* 则从头节点开始查找，否则从尾节点查找
* 查找位置 index 如果小于节点数量的一半，
*/
if (index < (size >> 1)) {
Node<E> x = first;
// 循环向后查找，直至 i == index
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;
}
}
上面的代码比较简单，主要是通过遍历的方式定位目标位置的节点。获取到节点后，取出节点存储的值返回即可。这里面有个小优化，即通过比较 index 与节点数量 size/2 的大小，决定从头结点还是尾节点进行查找。查找操作的代码没什么复杂的地方，这里先讲到这里。
遍历
链表的遍历过程也很简单，和上面查找过程类似，我们从头节点往后遍历就行了。但对于 LinkedList 的遍历还是需要注意一些，不然可能会导致代码效率低下。通常情况下，我们会使用 foreach 遍历 LinkedList，而 foreach 最终转换成迭代器形式。所以分析 LinkedList 的遍历的核心就是它的迭代器实现，相关代码如下：
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
/** 构造方法将 next 引用指向指定位置的节点 */
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next; // 调用 next 方法后，next 引用都会指向他的后继节点
nextIndex++;
return lastReturned.item;
}
// 省略部分方法
}
上面的方法很简单，大家应该都能很快看懂，这里就不多说了。下面来说说遍历 LinkedList 需要注意的一个点。
我们都知道 LinkedList 不擅长随机位置访问，如果大家用随机访问的方式遍历 LinkedList，效率会很差。比如下面的代码：
List<Integet> list = new LinkedList<>();
list.add(1)
list.add(2)
......
for (int i = 0; i < list.size(); i++) {
Integet item = list.get(i);
// do something
}
当链表中存储的元素很多时，上面的遍历方式对于效率来说就是灾难。原因在于，通过上面的方式每获取一个元素，LinkedList 都需要从头节点（或尾节点）进行遍历，效率不可谓不低。在电脑配置如下（MacBook Pro Early 2015, 2.7 GHz Intel Core i5）实测10万级的数据量，耗时约7秒钟。20万级的数据量耗时达到了约34秒的时间。50万级的数据量耗时约250秒。从测试结果上来看，上面的遍历方式在大数据量情况下，效率很差。大家在日常开发中应该尽量避免这种用法。
插入
LinkedList 除了实现了 List 接口相关方法，还实现了 Deque 接口的很多方法，所以我们有很多种方式插入元素。但这里，我只打算分析 List 接口中相关的插入方法，其他的方法大家自己看吧。LinkedList 插入元素的过程实际上就是链表链入节点的过程，学过数据结构的同学对此应该都很熟悉了。这里简单分析一下，先看源码吧：
/** 在链表尾部插入元素 */
public boolean add(E e) {
linkLast(e);
return true;
}
/** 在链表指定位置插入元素 */
public void add(int index, E element) {
checkPositionIndex(index);
// 判断 index 是不是链表尾部位置，如果是，直接将元素节点插入链表尾部即可
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
/** 将元素节点插入到链表尾部 */
void linkLast(E e) {
final Node<E> l = last;
// 创建节点，并指定节点前驱为链表尾节点 last，后继引用为空
final Node<E> newNode = new Node<>(l, e, null);
// 将 last 引用指向新节点
last = newNode;
// 判断尾节点是否为空，为空表示当前链表还没有节点
if (l == null)
first = newNode;
else
l.next = newNode; // 让原尾节点后继引用 next 指向新的尾节点
size++;
modCount++;
}
/** 将元素节点插入到 succ 之前的位置 */
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
// 1. 初始化节点，并指明前驱和后继节点
final Node<E> newNode = new Node<>(pred, e, succ);
// 2. 将 succ 节点前驱引用 prev 指向新节点
succ.prev = newNode;
// 判断尾节点是否为空，为空表示当前链表还没有节点
if (pred == null)
first = newNode;
else
pred.next = newNode; // 3. succ 节点前驱的后继引用指向新节点
size++;
modCount++;
}
The above is the source of the insertion process, I conducted a more detailed source notes, should not be difficult to understand. The above two methods only add to the list the method of operating a wrapper made, and core logic linkBefore in linkLast. In this linkBefore example, its logical flow follows:
- Create a new node, and indicates the new node predecessor and successor
- The succ precursor references point to the new node
- If succ precursor is not empty, then succ predecessor successor references point to the new node
Corresponding to the following diagram:
These are inserted into the relevant source code analysis, it is not complicated, not to say. Continue to analyze down.
delete
If you read the source code inserted above analysis, then look deletion actually very simple. Delete operations to be released by deleting nodes and node before and after the link to complete the task. Process is relatively simple, look at the source code it:
public boolean remove(Object o) {
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;
}
public E remove(int index) {
checkElementIndex(index);
// 通过 node 方法定位节点，并调用 unlink 将节点从链表中移除
return unlink(node(index));
}
/** 将某个节点从链表中移除 */
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 为空，表明删除的是头节点
if (prev == null) {
first = next;
} else {
// 将 x 的前驱的后继指向 x 的后继
prev.next = next;
// 将 x 的前驱引用置空，断开与前驱的链接
x.prev = null;
}
// next 为空，表明删除的是尾节点
if (next == null) {
last = prev;
} else {
// 将 x 的后继的前驱指向 x 的前驱
next.prev = prev;
// 将 x 的后继引用置空，断开与后继的链接
x.next = null;
}
// 将 item 置空，方便 GC 回收
x.item = null;
size--;
modCount++;
return element;
}
And insert operations, deleting method is to ensure that the underlying process layer, the core logic in the underlying unlink method. So drive straight, direct analysis method unlink it. Logic unlink method is as follows (assuming the removed node is head node is neither nor tail node):
- The precursor to be deleted node x pointing successor successor of x
- The precursor to delete a reference to the node x blank, with precursor disconnect links
- The subsequent precursor to be deleted node x points to the predecessor of x
- The successor to delete a reference to the node x blank, disconnect and subsequent links
The diagram below:
In conjunction with the drawing, understanding LInkedList deletion should not be difficult. Well, deletion of source code analysis LinkedList talked about this.
to sum up
Through the above analysis, it should be very clear that the underlying LinkedList implements. Overall LinkedList source code is not complicated, we look at the patient in general can understand. At the same time, through this paper, we show the use of a LinkedList pit, I hope you try to avoid in development. Well, this article to end here, thanks for reading!