LinkedList的数据结构就是一个双向链表，这就决定了它具有很好的增删节点的性能。当需要在链表中间增加或者删除一个节点时，受影响的只是修改位置的前后两个节点，而不像ArrayList那样需要移动修改位置后面所有节点的位置。其数据结构图如下所示：
一、类的定义
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0;
// 链表第一个节点
transient Node<E> first;
// 链表最后一个节点
transient Node<E> last;
}
从上面代码中看到，LinkedList继承了AbstractSequentialList，而AbstractSequentialList继承自AbstractList。AbstractSequentialList抽象类定义一些方法提供了随机访问的功能，让客户端访问链表跟数组一样方便，这些方法包括add(int index, E element) ，get(int index)。实现List是为了兼容动态代理，具体的分析可以参考上篇文章。实现Deque接口提供了双端队列的功能。实现Cloneablle接口具备了克隆功能。内部有三个成员变量，size表示链表的长度，first是链表的第一个节点，last是链表的最后一个节点。
二、构造函数
// 默认构造函数
public LinkedList() { }
// 把集合参数的数据插入到链表
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
三、存储的实现
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节点数据是用Node对象存储的，item是存储的数据，next指向下一个节点，prev指向上一个节点。通过这样的存储结构，LinkedList就可以构造一条双项链表了。
1.add(E e)方法
public boolean add(E e) {
// 在链表后面插入节点
linkLast(e);
return true;
}
// 在链表后面插入节点
void linkLast(E e) {
final Node<E> l = last;
// 创建一个新节点
final Node<E> newNode = new Node<>(l, e, null);
// 链表最后一个节点就是最新创建的节点
last = newNode;
// 如果最后一个节点为空，则最新创建的节点为第一个节点；否则上一个节点的下一个节点为新创建的节点
if (l == null)
first = newNode;
else
l.next = newNode;
// 链表长度加一
size++;
// fast-fail机制
modCount++;
}
从上面代码中可以看到，调用add(E e)方法会在链表的后面衔接新的节点，可以保持“先进先出”的特性。
2.add(int index, E element)方法
在指定位置插入新的节点
public void add(int index, E element) {
// 检测插入位置是否合法
checkPositionIndex(index);
// 如果插入位置等于链表的长度，则调用从后面插入新节点的方法，
// 可以省去找出index位置的元素的操作，这是一种提高代码效率的方法，值得我们学习。
// 如果判断为false，则在index节点的前面插入新的节点
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
// 位置合法性检测
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 判断是否是有效的位置
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
// 在index节点前面插入节点
void linkBefore(E e, Node<E> succ) {
final Node<E> pred = succ.prev;
// 创建新的节点
final Node<E> newNode = new Node<>(pred, e, succ);
// index位置节点的上一个节点为新创建的节点
succ.prev = newNode;
// 如果index的上一个节点为null，说明index节点是之前的第一个节点，
// 此时第一个节点为新创建的节点。如果上一个节点不为空，则新节点为
// 之前上一个节点的下一个节点（有点拗口，懂得链表原理容易理解）
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
// 获取index位置的节点
Node<E> node(int index) {
// 如果index小于链表长度的一半，则从链表的前面开始查找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;
}
}
3.get(int index)方法
public E get(int index) {
// index合法性检测
checkElementIndex(index);
// 直接返回index处节点保存的数据
return node(index).item;
}
有了之前方法的分析，对于get方法理解是水到渠成的了，这种操作的时间复杂度是O(n)。
4.push(E e)方法
LinkedList实现了Deque接口，自然它就得实现堆栈的方法，push方法是往堆栈推入元素，实现“后进先出”的功能。在链表中就是往链表的前面插入节点。
public void push(E e) {
addFirst(e);
}
public void addFirst(E e) {
linkFirst(e);
}
// 在链表第一个节点前面插入新的节点，代码要考虑的是插入前链表是否为空，
// 即开始时first是否为null，为null的话链表最后一个节点也是新插入的节点
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
5. pop()方法
pop方法也是堆栈的方法，就是把堆栈上面的元素弹出。对应链表就是把链表的第一个节点返回，并且使其从链表中断开。
public E pop() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
// 如果第一个节点为空则抛出异常
if (f == null)
throw new NoSuchElementException();
// 把第一个节点作为参数传入
return unlinkFirst(f);
}
// 断开链表中的第一个节点，并且返回
private E unlinkFirst(Node<E> f) {
final E element = f.item;
final Node<E> next = f.next;
// 把item和next设置为null，以便gc回收
f.item = null;
f.next = null;
// 此时链表的第一个节点为之前的下一个节点
first = next;
// 如果链表没有节点了，则最后一个节点也为null。否则此时链表的第一个节点的上一个节点为null
if (next == null)
last = null;
else
next.prev = null;
// 链表长度减一
size--;
modCount++;
// 返回断开节点的数据
return element;
}
四、遍历操作
LinkedList的遍历操作是通过内部类ListItr 实现ListIterator接口完成的，ListIterator接口继承自Iterator接口，新增了一些功能，包括遍历上一个元素、设置当前遍历的节点的值、在遍历的位置前面插入一个节点。具体源码如下所示，其操作跟ArrayList类似
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned = null;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// 可以指定遍历开始的位置，普通迭代器是从0开始
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;
nextIndex++;
return lastReturned.item;
}
// 是否有上一个节点
public boolean hasPrevious() {
return nextIndex > 0;
}
// 返回上一个节点
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
// 返回下一个遍历的位置
public int nextIndex() {
return nextIndex;
}
// 返回上一个遍历的位置
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
// 设置当前遍历的节点值
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
// 在当前遍历位置前面插入一个节点
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 检查是否多线程更改链表，fast-fail机制
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
五、总结
- LinkedList的数据结构是链表，当需要经常在集合内部做节点增删操作时，可以优先考虑使用LinkedList。
- LinkedList没有长度或者大小的限制。
- LinkedList实现了Deque接口，可以当做堆栈来使用。
- LinkedList不是线程安全的，应该避免多线程操作。
- LinkedList继承了AbstractSequentialList抽象类，也可以做随机访问，但时间复杂度要比数组高。
93
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
