LinkedList简介
LinkedList是基于双向循环链表（从源码中可以很容易看出）实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。
LinkedList在内部定义了一个叫做Entry类型的内部类(1.7之后换成了Node内部类)，这个Entry就是一个节点，链表中的节点，这个节点有3个属性，分别是元素item(当前节点要表示的值), 前节点prev(当前节点之前位置上的一个节点)，后节点next(当前节点后面位置的一个节点)。
LinkedList提供高效的插入,删除元素的功能。但是不具备ArrayList那种高效的随机访问。
LinkedList源码剖析
基于JDK 1.6和最新的JDK的数据结构稍微有点出入,但是思路是一样的，80%代码都已经给出。
public class MyLinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable {
private static final long serialVersionUID = -3358195569371661044L;
// 集合链表内节点数量
transient int size = 0;
// 链表的表头，表头不包含任何数据。Entry是个链表类数据结构。
private transient Entry header = new Entry(null, null, null);
// 默认构造函数：创建一个空的链表
public MyLinkedList() {
header.next = header.previous = header;
}
// 包含“集合”的构造函数:创建一个包含“集合”的LinkedList
public MyLinkedList(Collection c) {
addAll(c);
}
// 将“集合(c)”添加到LinkedList中。
// 实际上，是从双向链表的末尾开始，将“集合(c)”添加到双向链表中。
public boolean addAll(Collection c) {
return addAll(size, c);
}
// 从双向链表的index开始，将“集合(c)”添加到双向链表中。
public boolean addAll(int index, Collection c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: " + index +
", Size: " + size);
Object[] a = c.toArray();
// 获取集合的长度
int numNew = a.length;
if (numNew == 0)
return false;
modCount++;
// 设置“当前要插入节点的后一个节点”
Entry successor = (index == size ? header : entry(index));
// 设置“当前要插入节点的前一个节点”
Entry predecessor = successor.previous;
// 将集合(c)全部插入双向链表中
for (int i = 0; i < numNew; i++) {
Entry e = new Entry((T) a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;
// 调整LinkedList的实际大小
size += numNew;
return true;
}
// 双向链表的节点所对应的数据结构。
// 包含3部分：上一节点，下一节点，当前节点值。
private static class Entry {
// 当前节点所包含的值
T element;
// 下一个节点
Entry next;
// 上一个节点
Entry previous;
public Entry(T element, Entry next, Entry previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
// 将节点数据是e的添加到entry节点之前。
private Entry addBefore(T e, Entry entry) {
// 新建节点newEntry，将newEntry插入到节点e之前；并且设置newEntry的数据是e
Entry newEntry = new Entry<>(e, entry, entry.previous);
newEntry.next.previous = newEntry;
newEntry.previous.next = newEntry;
size++;
modCount++;
return newEntry;
}
// 将节点从链表中删除(LinkedList所有remove方法最终都调用这个)
private T remove(Entry e) {
if (e == header)
throw new NoSuchElementException();
T result = e.element;
e.next.previous = e.previous;
e.previous.next = e.next;
e.previous = e.next = null;
e.element = null;
size--;
modCount++;
return result;
}
// 将元素e添加到LinkedList中
public boolean add(T e) {
// 将节点(节点数据是e)添加到表头(header)之前。即，将节点添加到双向链表的末端
addBefore(e, header);
return true;
}
// 在index前添加节点，且节点的值为element
public void add(int index, T element) {
addBefore(element, (index == size ? header : entry(index)));
}
// 从LinkedList中删除元素(o)
// 从链表开始查找，如存在元素(o)则删除该元素并返回true；否则，返回false
@Override
public boolean remove(Object o) {
if (o == null) {
// 若o为null的删除情况
for (Entry e = header.next; e != header; e = e.next) {
if (e.element == null) {
remove(e);
return true;
}
}
} else {
// 若o不为null的删除情况
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
// remove一个位置index的节点
@Override
public T remove(int index) {
return remove(entry(index));
}
// 获取双向链表中指定位置的节点, 很重要的方法!!!
private Entry entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
Entry h = header;
// 获取index处的节点。
// 若index < 双向链表长度的1/2,则从前先后查找;
// 否则，从后向前查找。
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
h = h.next;
} else {
for (int i = size; i > index; i--)
h = h.previous;
}
return h;
}
@Override
public boolean offerFirst(T t) {
addFirst(t);
return true;
}
@Override
public boolean offerLast(T t) {
addLast(t);
return true;
}
@Override
public T removeFirst() {
return remove(header.next);
}
@Override
public T removeLast() {
return remove(header.previous);
}
@Override
public T pollFirst() {
if (size == 0)
return null;
return removeFirst();
}
@Override
public T pollLast() {
if (size == 0)
return null;
return removeLast();
}
@Override
public T getFirst() {
if (size==0)
throw new NoSuchElementException();
// 链表的表头header中不包含数据。
// 这里返回header所指下一个节点所包含的数据。
return header.next.element;
}
@Override
public T getLast() {
if (size==0)
throw new NoSuchElementException();
// 由于LinkedList是双向链表；而表头header不包含数据。
// 因而，这里返回表头header的前一个节点所包含的数据。
return header.previous.element;
}
@Override
public T peekFirst() {
if (size == 0)
return null;
return getFirst();
}
@Override
public T peekLast() {
if (size == 0)
return null;
return getLast();
}
@Override
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
// 从LinkedList末尾向前查找，删除第一个值为元素(o)的节点
// 从链表开始查找，如存在节点的值为元素(o)的节点，则删除该节点
@Override
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Entry e = header.previous; e != header; e = e.previous) {
if (e.element == null) {
remove(e);
return true;
}
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
@Override
public boolean offer(T t) {
return add(t);
}
@Override
public T remove() {
return removeFirst();
}
@Override
public T poll() {
if (size == 0)
return null;
return removeFirst();
}
@Override
public T element() {
return getFirst();
}
// 返回第一个节点
@Override
public T peek() {
if (size == 0)
return null;
return getFirst();
}
@Override
public void push(T t) {
addFirst(t);
}
@Override
public T pop() {
return removeFirst();
}
@Override
public int size() {
return size;
}
@Override
public boolean contains(Object o) {
return indexOf(o) != -1;
}
// 从前向后查找，返回“值为对象(o)的节点对应的索引”
// 不存在就返回-1
@Override
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element == null)
return index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index++;
}
}
return -1;
}
// List迭代器
// 返回“index到末尾的全部节点”对应的ListIterator对象, list.iterator(); 方法调用的就是这个方法最后, (index=0)
@Override
public ListIterator listIterator(int index) {
return new ListItr(index);
}
// ListItr内部类
private class ListItr implements ListIterator {
// 下一个节点
private Entry next;
// 上一次返回的节点
private Entry lastReturned = header;
// 下一个节点对应的索引值
private int nextIndex;
// 期望的改变计数。用来实现fail-fast机制。
private int expectedModCount = modCount;
public ListItr(int index) {
// index的有效性处理
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
// 若 “index 小于 ‘双向链表长度的一半’”，则从第一个元素开始往后查找；
// 否则，从最后一个元素往前查找。
if (index < (size >> 1)) {
// 初始化下一个节点
next = header.next;
for (nextIndex = 0; nextIndex < index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex = size; nextIndex > index; nextIndex--)
next = next.previous;
}
}
// 是否存在下一个元素
@Override
public boolean hasNext() {
// 通过元素索引是否等于“双向链表大小”来判断是否达到最后。
return nextIndex != size;
}
// 获取下一个元素
@Override
public T next() {
checkForComodification();
int i = nextIndex;
if (i >= size)
throw new NoSuchElementException();
nextIndex++;
lastReturned = next;
// next指向链表的下一个元素
next = next.next;
return lastReturned.element;
}
@Override
public boolean hasPrevious() {
// 通过元素索引是否等于0，来判断是否达到开头。
return nextIndex != 0;
}
@Override
public T previous() {
if (nextIndex == 0)
throw new NoSuchElementException();
// next指向链表的上一个元素
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
// 获取下一个元素的索引
@Override
public int nextIndex() {
return nextIndex;
}
@Override
public int previousIndex() {
return nextIndex - 1;
}
// 删除双向链表中的当前节点
@Override
public void remove() {
checkForComodification();
Entry lastNext = lastReturned.next;
try {
MyLinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
// 重置lastReturned
lastReturned = header;
expectedModCount++;
}
@Override
public void set(T e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
@Override
public void add(T e) {
checkForComodification();
// 重置lastReturned
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 判断 “modCount和expectedModCount是否相等”，依次来实现fail-fast机制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
// 返回LinkedList的Object[]数组
public Object[] toArray() {
// 新建Object[]数组
Object[] result = new Object[size];
int i = 0;
// 将链表中所有节点的数据都添加到Object[]数组中
for (Entry e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}
// 返回LinkedList的模板数组。所谓模板数组，即可以将T设为任意的数据类型
public T[] toArray(T[] a) {
// 若数组a的大小 < LinkedList的元素个数(意味着数组a不能容纳LinkedList中全部元素)
// 则新建一个T[]数组，T[]的大小为LinkedList大小，并将该T[]赋值给a。
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
// 将链表中所有节点的数据都添加到数组a中
int i = 0;
Object[] result = a;
for (Entry e = (Entry) header.next; e != header; e = e.next)
result[i++] = e.element;
if (a.length > size)
a[size] = null;
return a;
}
// 克隆函数。返回LinkedList的克隆对象。
public Object clone() {
MyLinkedList clone = null;
// 克隆一个LinkedList克隆对象
try {
clone = (MyLinkedList) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// 新建LinkedList表头节点
clone.header = new Entry(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// 将链表中所有节点的数据都添加到克隆对象中
for (Entry e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
}
源码几个重点方法讲解
private Entry
addBefore(T e, Entry entry)；
这个方法就是将节点数据是e的添加到某个entry节点之前，如下图所示，在1节点之前加入0节点
1. 先新建节点newEntry。
2. 新建节点newEntry的next和previous引用分别指向1节点和3节点。
3. 3节点的next和1节点的previous指向新建节点newEntry。
addBefore.png
private T remove(Entry
e)
// 将节点从链表中删除(LinkedList所有remove方法最终都调用这个)
这个方法就是将节点数据e的删除，如下图所示，删除1节点：
1. 先把3节点next引用从指向1节点变成指向7节点。
2. 再把7节点previous引用从指向1节点变成指向3节点。
3. 清空1节点的previous和next节点，都指向null。
3. 清空1节点的previous和next节点element数据，使得element ＝ null;
等待GC。
remove.png
LinkedList和ArrayList的比较
LinkedList和ArrayList的设计理念完全不一样，ArrayList基于数组，而LinkedList基于节点，也就是链表。所以LinkedList内部没有容量这个概念，因为是链表，链表是无界的
两者的使用场景不同，ArrayList适用于读多写少的场合。LinkedList适用于写多读少的场合。 刚好相反。 那是因为LinkedList要找节点的话必须要遍历一个一个节点，直到找到为止。而ArrayList完全不需要，因为ArrayList内部维护着一个数组，直接根据索引拿到需要的元素即可。