LinkedList源码分析
LinkedList类图
LinkedList是java.util包下的Collection接口下的一个子类，也是我们常用的容器，底层是一个双向链表，也可以当做双端无界队列使用，而我们知道，双端队列其实也相当于一个栈，因此LinkedList其实是一个具有多种功能的容器。
- AbstractSequentialList抽象类：AbstractList的子类，实现一些集合的通用的方法（添加、获得等，通过迭代器实现，隐藏了对下标的操作）。
- Cloneable接口：实现对象拷贝必须要实现的接口。
- Serializable接口：实现序列化必须要实现的接口。
- Deque接口：Queue接口下的一个子接口，扩展了队列相关的操作。
LinkedList属性
以上便是LinkedList的属性，下面一一介绍：
size
transient int size = 0;
链表里元素的个数。
first
transient Node first;
链表的头结点。
last
transient Node last;
链表的尾节点。
注意：以上三个属性都是被transient关键字修饰，表示不可被序列化。LinkedList的序列化是通过反射调用重写的readObject方法和writeObject方法实现的，之所以如此做是为了只序列化存储的数据。（具体可以参考别的博客）
serialVersionUID
private static final long serialVersionUID = 876323262645176354L;
序列化ID
Node
private static class Node {
E item;
Node next;
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
} LinkedList的一个static内部类，链表里的每个节点都是通过Node来存储的，包含item，next，prev三个属性，item用来存储值，next用来存储后指针，prev用来存储前指针。
LinkedList常用API
public LinkedList() {
}
public LinkedList(Collection c) {
this();
addAll(c);
}
构造方法：
- 空参的构造方法什么都没有做，只是实例化first和last两个Node节点
- 带Collection参数的构造方法首先调用空参构造方法，然后调用addAll方法来将Collection集合添加进链表中。
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
} add方法：向链表中插入一个元素
add方法会调用linkLast方法，该方法是在链表的最后插入一个元素。
- 首先将尾节点保存起来（l）
- 然后创建值为e的新节点，将之前的尾节点设置为它的前指针
- 将新节点作为现在尾节点
- 判断之前的尾节点是否为null，即是否是第一次添加节点，如果是，则链表的首节点也是新节点，如果不是，将之前的尾节点的后指针指向现在的尾节点
public boolean remove(Object o) {
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
E unlink(Node x) {
// assert x != null;
final E element = x.item;
final Node next = x.next;
final Node 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;
}
remove方法：移除指定元素。
- 首先遍历链表，如果没有找到该元素，直接返回false
- 如果找到该元素，则调用unlink方法将该元素移除
- 先将该元素的前后指针保存下来
- 然后判断该元素是否是首节点，如果是首节点，则将他的下一个节点当做首节点，如果不是，则将上一个节点的后指针指向它的下一个节点，将他的前指针置为null
- 然后判断该元素是否是尾节点，如果是尾节点，则将他的前一个节点当做尾节点，如果不是，则将下一个节点的前指针指向他的上一个节点，将他的后指针置为null
- 将他的值置为null（方便GC回收），size--，modcount++，modcount指的是修改的次数，与迭代器遍历有关
public boolean addAll(Collection c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node 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 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;
} addAll方法：将一个Collection集合的元素添加到链表里。
第一个addAll方法会调用带下标的addAll方法，表示将元素要插入的位置，因此addAll默认是将元素全部插入链表尾。
- 首先调用checkPositionIndex方法来检查下标是否合理（>=0且<=size），如果不合理，抛出异常
- 然后将collection集合转化为数组，判断数组里元素个数，如果为0则直接返回false
- 然后初始化两个Node，这两个节点可以用来判断要插入的位置
- 遍历数组，将元素全部插入
- 根据之前初始化的两个Node来判断是插入链表尾还是插入其余位置，然后更新相应的头结点或者尾节点
- 更新size个数，modcount++
public void addFirst(E e) {
linkFirst(e);
}
public void addLast(E e) {
linkLast(e);
}
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
public E removeLast() {
final Node l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
addFirst方法：在链表头部加入一个节点
addLast方法：在链表尾部加入一个节点
removeFirst方法：删除链表头部第一个元素
removeLast方法：删除链表尾部第一个元素
linkLast和linkFirst方法之前介绍过，这里不再赘述。
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
Node node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
} get方法：获得指定下标的元素。
- 首先调用checkElementIndex方法来验证下标是否合理
- 然后调用node方法来获得指定下标的元素
- 首先size右移一位，即size除以2，获得元素的中间下标
- 如果index
- 反之index>mid，则要查找的下标离尾节点更近，从尾节点遍历查找
public E set(int index, E element) {
checkElementIndex(index);
Node x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
} set方法：修改指定下标的元素值。
- 首先调用checkElementIndex方法来验证下标是否合理
- 然后调用node方法来获得指定下标的元素
- 然后更新该元素并返回旧的元素值
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
for (Node x = first; x != null; ) {
Node next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
} clear方法：清空链表。
- 遍历链表，所有属性置为null（方便GC回收）
- 头结点和尾节点置为null，size归零，modcount++
public boolean contains(Object o) {
return indexOf(o) != -1;
}
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
} contains方法：判断列表中是否存在某个元素。
调用indexOf方法来查找该元素，如果不存在，返回下标为-1
indexOf方法：从头结点开始遍历，如果找到，返回对应下标，如果没找到，返回-1
public int size() {
return size;
}size方法：返回当前链表中的元素个数。
================================================================================================
======================= 以上方法均是操作链表的方法 以下方法用来操作队列 ===============================
================================================================================================
public E poll() {
final Node f = first;
return (f == null) ? null : unlinkFirst(f);
} poll方法：弹出队列元素，从链表头部取出，如果是空链表则返回null，会将链表头结点删除
public E pop() {
return removeFirst();
}
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
} pop方法：弹出队列元素，从链表头部取出，如果是空链表则会抛出异常，会将链表头结点删除
public E peek() {
final Node f = first;
return (f == null) ? null : f.item;
} peek方法：查看队头元素，从链表头部取出，如果是空链表则会返回null，不会将链表头结点删除
public void push(E e) {
addFirst(e);
}
push方法：向队列中添加一个元素，从链表的头部插入
总结
- LinkedList底层是一个双向链表。
- LinkedList还实现了Queue的子接口Deque，实现了一些队列的方法，因此他还是一个双端无界队列，而双端无界队列也可以用来当做栈使用。
- LinkedList在队列首尾添加元素非常高效，时间复杂度为O(1)，在中间添加删除的时间复杂度为O(n)。
- LinkedList为了性能考虑，一方面在删除元素或者清空链表时，不只是将链表切断，而且会将切除的Node节点全部置为null，方便GC回收，另一方面，他实现了序列化接口，但又将存储数据的前指针、后指针、元素个数等属性设置为transient，禁止自动序列化，而是通过实现readObject和writeObject方法来只序列化实际存储的数据，减少空间的占用。