【Java集合类源码分析】LinkedList源码分析
一、LinkedList简介
LinkedList是基于双向链表实现的，除了可以当作链表来操作外，也可以当作栈、队列和双端队列进行操作。 
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable LinkedList继承了AbstarctList抽象类，实现了List及Deque接口。
LinkedList实现了Cloneable接口，支持克隆；实现了Serializable接口，支持序列化，能够通过序列化传输。
LinkedList同样是非线程安全的，在单线程环境下使用。
二、LinkedList源码分析（JDK1.8）
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
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;
}
}
/**
* 实际元素个数
*/
transient int size = 0;
/**
* 指向第一个节点
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* 指向最后一个结点
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
public LinkedList() {
}
/**
* 构造一个包含指定集合元素的列表
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
/**
* e作为第一个元素
*/
private void linkFirst(E e) {
//保存头结点，f为final类型，不可更改
final Node<E> f = first;
//构造一个前驱为null,值为e,后继为f的新结点newNode
final Node<E> newNode = new Node<>(null, e, f);
//将newNode作为头结点
first = newNode;
if (f == null) //头结点为空，则原链表为空
last = newNode; //将newNode同时设为尾结点
else //头结点不为空
f.prev = newNode; //原头结点的前驱设置为newNode
size++;
modCount++;
}
/**
* e作为最后一个元素
*/
void linkLast(E e) {
//保存尾结点，l为final类型，不可更改
final Node<E> l = last;
//构造一个前驱为l,值为e，后继为null的新结点newNode
final Node<E> newNode = new Node<>(l, e, null);
//将newNode作为尾结点
last = newNode;
if (l == null) //尾结点为空,即原链表为空
first = newNode; //将newNode同时设为头结点
else //尾结点不为空
l.next = newNode; //原尾结点的后继设置为newNode
size++;
modCount++;
}
/**
* 在非空节点succ之前插入元素e
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
//保存succ的前驱结点pred
final Node<E> pred = succ.prev;
//构造一个前驱为pred,值为e，后继为succ的新结点newNode
final Node<E> newNode = new Node<>(pred, e, succ);
//设置newNode为succ的前驱结点
succ.prev = newNode;
if (pred == null) //如果pred为空，即succ为头结点
first = newNode； //将newNode设置为头结点
else //如果pred不为空
pred.next = newNode; //将newNode设置为pred的后继
size++;
modCount++;
}
/**
* 取消链接非空头节点f，并返回结点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;
}
/**
* 取消链接非空尾节点l，并返回结点l
*/
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;
}
/**
* 取消链接非空节点x，并返回结点x
*/
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;
}
/**
* 返回此列表中的第一个元素
*/
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 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);
}
/**
* 将指定的元素插入到此列表的开头
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 将指定的元素追加到此列表的末尾
*/
public void addLast(E e) {
linkLast(e);
}
/**
* 如果此列表包含指定的元素，则返回true
*/
public boolean contains(Object o) {
return indexOf(o) != -1;
}
/**
* 返回此列表中的元素数量
*/
public int size() {
return size;
}
/**
* 新增元素(即将指定的元素追加到此列表的末尾)
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 从列表中删除第一个出现的指定元素（如果存在）
*/
public boolean remove(Object o) {
if (o == null) { //说明LinkedList允许元素为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 boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/**
* 从指定的位置开始，将指定集合中的所有元素插入到此列表中
*/
public boolean addAll(int index, Collection<? extends E> c) {
//检查插入的位置是否合法（index >= 0 && index <= size）
checkPositionIndex(index);
//将集合转化为数组
Object[] a = c.toArray();
//保存集合大小
int numNew = a.length;
if (numNew == 0) //若集合为空
return false;
Node<E> pred, succ;
if (index == size) { //若插入位置为链表尾(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) //若插入位置为链表头(index=0，表示在头前插入)
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;
}
/**
* 从列表中删除所有元素.
*/
public void clear() {
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
// Positional Access Operations 位置访问操作
/**
* 返回此列表中指定位置的元素.
*/
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
/**
* 用指定的元素替换此列表中指定位置的元素
*/
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
/**
* 在此列表中的指定位置插入指定的元素.
*/
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
/**
* 删除该列表中指定位置的元素，并返回从列表中删除的元素
*/
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
* 判断参数是否是存在元素的索引
*/
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
/**
* 判断参数是否是迭代器或添加操作时有效位置的索引
*/
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
/**
* 构造一个IndexOutOfBoundsException详细消息.
*/
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 返回指定元素索引处的（非空）节点
*/
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) { //折半思想，当index < size/2时，从列表首节点向后查找
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else { //当index >= size/2时，从列表尾节点向前查找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
// Search Operations 搜索操作
/**
* 返回此列表中指定元素的第一次出现的索引
*/
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;
}
// Queue operations 队列操作
/**
* 获取但不删除此队列的头（第一个元素），如果此队列为空，则返回 null
*/
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
/**
* 获取但不删除此队列的头（第一个元素），如果此队为空，则抛出NoSuchElementException异常
*/
public E element() {
return getFirst();
}
/**
* 获取并删除此队列的头（第一个元素），如果此队列为空，则返回 null
*/
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
/**
* 获取并删除此队列的头（第一个元素），如果此队列为空，则抛出NoSuchElementException异常
*/
public E remove() {
return removeFirst();
}
/**
* 将指定的元素添加为此队列的尾部（最后一个元素）
*/
public boolean offer(E e) {
return add(e);
}
// Deque operations 双端队列操作
/**
* 在此双端队列的开头插入指定的元素
*/
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
/**
* 在此双端队列的末尾插入指定的元素
*/
public boolean offerLast(E e) {
addLast(e);
return true;
}
/**
* 获取但不删除此双端队列的第一个元素，如果此双端队列为空，则返回 null
*/
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
/**
* 获取但不删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null
*/
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
/**
* 获取并删除此双端队列的第一个元素，如果此双端队列为空，则返回 null
*/
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
/**
* 获取并删除此双端队列的最后一个元素，如果此双端队列为空，则返回 null
*/
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
/**
* 将元素压入到由此列表表示的堆栈上。 换句话说，在该列表的头部插入元素
*/
public void push(E e) {
addFirst(e);
}
/**
* 从此列表表示的堆栈中弹出一个元素。 换句话说，删除并返回此列表的第一个元素
*/
public E pop() {
return removeFirst();
}
/**
* 删除此列表中第一个出现的指定元素（从头到尾遍历列表时）
* 如果列表不包含该元素，则它不会更改
*/
public boolean removeFirstOccurrence(Object o) {
return remove(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;
}
@SuppressWarnings("unchecked")
private LinkedList<E> superClone() {
try {
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
/**
* 返回此LinkedList实例的浅拷贝（元素本身不被克隆)
* @return a shallow copy of this {@code LinkedList} instance
*/
public Object clone() {
LinkedList<E> clone = superClone();
// Put clone into "virgin" state
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
/**
* 返回一个包含此列表中所有元素的数组，按照顺序（从第一个到最后一个元素）
*/
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
/**
* 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）
* 返回的数组的运行时类型是指定数组的运行时类型
* 如果列表适合指定的数组，则返回其中
* 否则，将为指定数组的运行时类型和此列表的大小分配一个新数组
*/
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
if (a.length > size)
a[size] = null;
return a;
}
private static final long serialVersionUID = 876323262645176354L;
/**
* 将此LinkedList实例的状态保存到流（即序列化）
*
* @serialData 列表的大小（它包含的元素的数量）被发送（int）
* 后面是正确顺序的所有元素（每个对象）
*/
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);
}
/**
* 从流中重构这个LinkedList实例（即反序列化它）
*/
@SuppressWarnings("unchecked")
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遍历方式
1、通过迭代器Iterator遍历
Iterator iter = list.iterator();
while (iter.hasNext()) {
System.out.println(iter.next());
} 2、通过迭代器ListIterator遍历
ListIterator lIter = list.listIterator();
//顺向遍历
while (lIter.hasNext()) {
System.out.println(lIter.next());
}
//逆向遍历
while (lIter.hasPrevious()) {
System.out.println(lIter.previous());
} 3、foreach循环遍历
for (String str : list) {
System.out.println(str);
}四、总结
1、LinkedList是基于链表实现的，因此不存在容量不足的问题，所以没有扩容的方法。
2、LinkedList是基于链表实现的，因此插入删除的效率高，查找的效率低（虽然有一个加速动作）。
3、注意源码中的Entry node(int index)方法。该方法返回双向链表中指定位置处的节点，而链表中是没有下标索引的，要指定位置出的元素，就要遍历该链表，从源码的实现中，我们看到这里有一个加速动作（折半思想）。源码中先将index与长度size的一半比较，如果index<(size>>1)，就只从位置0往后遍历到位置index处，而如果index>=(size>>1)，就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历，从而提高一定的效率（实际上效率还是很低）。
4、在查找和删除某元素时，源码中都划分为该元素为null和不为null两种情况来处理，LinkedList中允许元素为null。
5、LinkedList也采用了fail-fast机制，通过记录modCount参数来实现。
6、源码中还实现了队列、双端队列和栈的操作方法，因此LinkedList也可以作为队列、双端队列和栈来使用。