基本属性
LinkedList既是List的实现类，也是Queue的实现类，所以LinkedList也可以当作队列使用。LinkedList的属性有：
/**
* 存储的元素个数
*/
transient int size = 0;
/**
* 头节点
*/
transient Node<E> first;
/**
* 尾节点
*/
transient Node<E> last;
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包含实际存储的元素、指向上一个节点的指针、指向下一个节点的指针，所以LinkedList是一个双向链表，它提供了两个构造方法：
/**
* 构造一个空的list
*/
public LinkedList() {
}
/**
* 从另一个集合构建list，将集合c中的元素全部添加到当前list
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
链表操作
插入节点
在LinkedList里面，节点的插入分成三种情况，在头部插入、在尾部插入、在中间插入。
头部插入
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++;
}
- 首先复制头节点的引用，然后创建一个新节点（
newNode），并将newNode.next指向头节点。 - 将头节点的引用指向新节点。
- 如果头节点为
null，表明列表是空的，将尾节点引用也指向新节点就完了；否则将旧头节点的prev指向新节点（f.prev = newNode）。 这个过程图解如下：
尾部插入
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++;
modCount++;
}
尾部插入相对于头部插入来说是一个镜像的过程：
- 首先复制尾节点的引用，然后创建一个新节点并将新节点的
prev指向尾节点。 - 将尾节点的引用指向新节点。
- 如果尾节点为
null，表明列表是空的，将头节点的引用指向新节点就好了；否则将旧尾节点的next指向新节点。
中间插入
/**
* @param e 要插入的元素
* @param succ 插入元素的后继节点，既插入位置是在succ节点前面
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
- 首先保留
succ节点的prev引用，然后创建新节点，并且newNode.next = succ，newNode.prev = pred。 - 将
succ节点的prev指向新节点。 - 如果
pred节点为null，表示succ节点是头节点，将头节点的引用指向新节点就完成了；否则将pred节点的next指向新节点。 这个过程图解如下：
删除节点
删除也分成了三种情况。
头部删除
/**
* @param f 要删除的节点
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
- 复制要删除节点存储的元素和
next的引用。 - 将要删除节点的
item和next置为null，为了帮助垃圾回收。 - 将头节点指向被删除节点的
next节点，如果next节点为空，表明列表只存储了一个元素，将尾节点置为null就完了；否则将next的prev节点置为null。 过程图解如下：
尾部删除
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
尾部删除相对于头部删除来说，是一个镜像的过程。
- 复制要删除节点存储的元素和
prev引用。 - 将要删除节点的
item和prev置为null，帮助垃圾回收。 - 将尾节点指向要删除节点的
prev节点，如果prev节点为空，表明列表只有一个元素，将头节点置为空就完了；否则将prev节点的引用置为null。
中间删除
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;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
- 首先复制要删除节点的
item、next、prev引用。 - 如果
prev节点为null，表明被删除的节点是头节点，将头节点的引用指向next节点就完了；否则将prev.next指向next节点，并将被删除节点的prev置为null。 - 如果
next节点为null，表明被删除的节点是尾节点，将尾节点的引用指向prev节点就完了；否则将next.prev指向prev节点，并将被删除节点的next置为null。 过程图解如下：
元素操作
添加元素
单个元素的插入有两种类型的方法，一种继承自List，一种继承自Queue，因为LinkedList属于无界队列，所以对于插入来说，并不会抛出异常。
/**
* 尾部插入
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 在指定下标处插入，首先检测下标是否越界，然后确定插入的位置
*/
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
/**
* 头部插入
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 尾部插入
*/
public void addLast(E e) {
linkLast(e);
}
// 队列相关方法
/**
* 尾部插入（入队列）
*/
public boolean offer(E e) {
return add(e);
}
/**
* 头部插入
*/
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
/**
* 尾部插入
*/
public boolean offerLast(E e) {
addLast(e);
return true;
}
/**
* 头部插入
*/
public void push(E e) {
addFirst(e);
}
批量添加元素相关方法：
/**
* 在尾部插入多个元素
*/
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/**
* 在指定位置处插入多个元素
*/
public boolean addAll(int index, Collection<? extends E> c) {
// 首先检查是否越界
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
// 找到指定位置的前继节点和后继节点
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
// 从指定位置开始插入节点
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
// 更新最后一个插入的节点和原来后继节点相关的引用
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
删除元素
在LinkedList中，出队列时，如果通过remove方法，没有元素时会抛出异常，删除单个元素方法如下：
/**
* 头部删除（出队列），没有元素时，会抛出异常
*/
public E remove() {
return removeFirst();
}
/**
* 删除指定位置元素，先判断是否越界，然后删除对应节点
*/
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
* 删除指定元素，从头部开始查找，找到对应节点后，删除节点（从前往后）
*/
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 removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
/**
* 尾部删除
*/
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
/**
* 删除链表的第一个元素o
*/
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
/**
* 删除链表中的最后一个元素o，从尾节点开始查找（从后往前）
*/
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
// 队列相关方法
/**
* 出队列
*/
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
LinkedList批量删除元素是其父类AbstractCollection提供的，通过迭代器的删除实现，方法如下：
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
boolean modified = false;
Iterator<?> it = iterator();
while (it.hasNext()) {
if (c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}
访问元素
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
/**
* 查找指定位置的元素
*/
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node<E> node(int index) {
// assert isElementIndex(index);
// 如果指定位置小于 size / 2，从前往后查找，否者从后往前查找
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;
}
}
/**
* 查找指定元素的下标，从前往后查找第一次出现的位置
*/
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
/**
* 查找指定元素最后一次出现的下标，从后往前查找，第一次出现的位置
*/
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
// 队列相关方法
/**
* 返回队列中的第一个元素，如果队列为空，返回null
*/
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
/**
* 返回队列中的第一个元素，如果队列为空，抛出异常
*/
public E element() {
return getFirst();
}
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
其他
equals
LinkedList的equals方法由其父类AbstractList实现，方法如下：
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = ((List<?>) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
可以看到，两个List比较，只要存储元素的顺序和值相等，那么这两个List通过equals比较的时候，它们就是相等的。
hashcode
也是在AbstractList中实现：
public int hashCode() {
int hashCode = 1;
for (E e : this)
hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
return hashCode;
}
在Java集合框架中，List实现类的hashcode值随着其存储的元素改变而改变，所以不要将List的实现类作为HashMap的键。
序列化
LinkedList也是自己实现了序列化和反序列化逻辑，代码如下：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}
LinkedList元素实际上是保存在LinkedList.Node.item上，自定义是为了避免序列化额外的东西（Node.next和Node.prev）。
迭代器
和ArrayList类似，不要在foreach循环中，对链表进行修改，否则会抛出ConcurrentModificationException异常。
总结
LinkedList实际上是一个双向链表，它拥有链表头节点和尾节点的引用。- 能够存储
null元素，非线程安全，hashcode随着存储元素的变化而变化。 - 随机访问效率比较低，实际复杂度为
O(n)，n为你想访问的下标。
