LinkedList由双向链表实现，实现了List、Deque、Serializable、Cloneable接口，能被克隆和实例化。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
1.存储结构Node
包含了三个字段，item为数据项，next为当前节点的下一个节点，prev为当前节点的前一个节点。
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;
}
}
2.字段
成员变量也比较简单，包含了一个头结点和尾节点，size是链表中节点的个数。
/**
* 链表中节点的个数
*/
transient int size = 0;
/**
* 头结点
*/
transient Node<E> first;
/**
* 尾节点
*/
transient Node<E> last;
3.构造函数
/**
* 构造函数，什么也不做
*/
public LinkedList() {
}
/**
* 创建一个包含集合中元素的链表
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
4.添加方法
添加节点可以使用头插法也可以使用尾插法，默认使用尾插法添加新节点。
/**
* 在头结点添加节点
*/
private void linkFirst(E e) {
//记录当前的头节点
final Node<E> f = first;
//创建一个新节点，next指向头节点,prev为null
final Node<E> newNode = new Node<>(null, e, f);
//将newNode设为头节点
first = newNode;
//如果原来的头结点为空
if (f == null)
//将尾节点设为newNode，由于只有一个节点，newNode既是头结点又是尾节点
last = newNode;
else
//将原来的头结点的prev指向新创建的节点
f.prev = newNode;
//更新大小
size++;
modCount++;
}
/**
* 从尾部添加节点
*/
void linkLast(E e) {
//先保存尾节点
final Node<E> l = last;
//创建一个prev指向尾节点，next指向空的节点
final Node<E> newNode = new Node<>(l, e, null);
//将新节点设为尾节点
last = newNode;
//如果原来的链表是空链表
if (l == null)
//新节点也是头结点
first = newNode;
else
//将原来尾节点的next指向新节点
l.next = newNode;
size++;
modCount++;
}
/**
* 在succ之前插入非空节点
*/
void linkBefore(E e, Node<E> succ) {
// 获取succ的前一个节点
final Node<E> pred = succ.prev;
//创建新节点，prev指向succ的前一个节点，next指向succ
final Node<E> newNode = new Node<>(pred, e, succ);
//将succ的prev执行新创建的节点
succ.prev = newNode;
//如果succ是头结点
if (pred == null)
//将新创建的节点设为头结点
first = newNode;
else
//更新pred的next，将它指向新创建的节点
pred.next = newNode;
size++;
modCount++;
}
/**
* 在首部添加节点
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 在尾部添加节点
*/
public void addLast(E e) {
linkLast(e);
}
/**
* 添加节点，默认在尾部添加
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 将集合中的元素添加到链表
*/
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;
//pred要插入位置的前一个节点，succ为需要插入节点的位置
Node<E> pred, succ;
//如果要插入位置等于链表的大小，说明需要在尾节点后面添加
if (index == size) {
succ = null;
//pred指向要插入位置的前一个节点也就是尾节点
pred = last;
} else {//如果不在尾部添加
//寻找index位置的节点
succ = node(index);
//index位置的前一个节点
pred = succ.prev;
}
//遍历数组
for (Object o : a) {
//
@SuppressWarnings("unchecked") E e = (E) o;
//创建新节点，prev指向pred
Node<E> newNode = new Node<>(pred, e, null);
// 如果要插入位置的前一个节点是空，说明要插入位置是头结点
if (pred == null)
first = newNode;
else
//将要插入位置的前一个节点的next指向新创建的节点
pred.next = newNode;
//将pred指向当前节点
pred = newNode;
}
//如果要插入位置为null
if (succ == null) {
//将新插入的最后一个节点设为尾节点
last = pred;
} else {
//将新插入的最后一个节点的next指向原链表要插入位置的节点
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
/**
* 在指定位置添加节点
*/
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
//在尾部添加
linkLast(element);
else
//找到index处的节点，然后在该节点前添加新节点
linkBefore(element, node(index));
}
5.获取和查找
（1）LinkedList提供了正向查找和反向查找两种方法，需要对整个链表进行遍历，如果找到返回对象在链表中的位置。
（2）如果根据索引查找，LinkedList会根据链表中节点的个数/2算出中间位置的索引，然后比较，如果大于中间位置的索引，从中间索引之后开始查找，否则反之。
/**
* 获取头结点
*/
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;
}
/**
* 是否包含对象o
*/
public boolean contains(Object o) {
return indexOf(o) != -1;
}
/**
* 根据位置获取节点
*/
public E get(int index) {
//检查位置是否合法
checkElementIndex(index);
return node(index).item;
}
/**
* 根据位置找到相应的节点
*/
Node<E> node(int index) {
// assert isElementIndex(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;
}
}
// 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;
}
6.删除
（1）从remove方法中可以看出如果删除的节点是null的话是单独进行处理的，LinkedList是允许null值插入的。
（2）删除节点时同样需要遍历链表，寻找要删除的节点，然后删除。
/**
* 删除节点
*/
public boolean remove(Object o) {
//如果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 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++;
}
/**
* 删除节点
*/
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
7.更新
/**
* 更新节点的值
*/
public E set(int index, E element) {
checkElementIndex(index);
//根据位置找到该节点
Node<E> x = node(index);
E oldVal = x.item;
//更新节点的值
x.item = element;
return oldVal;
}
8.Queue操作和Dequeue操作
由于LinkedList实现了Queue接口，可以使用LinkedList模拟队列和双端队列，因此提供了一些队列的操作方法。
/**
* 返回头结点的数据，如果此队列为空，则返回 null
*/
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
/**
* 获取但不移除此队列的头；如果此队列为空，则抛出NoSuchElementException异常
*/
public E element() {
return getFirst();
}
/**
* 获取并移除此队列的头，如果此队列为空，则返回 null
* @return
*/
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
/**
* 获取并移除此队列的头，如果此队列为空，则抛出NoSuchElementException异常
* @return
*/
public E remove() {
return removeFirst();
}
/**
* 将指定的元素插入队列，从尾部插入
* @param e
* @return
*/
public boolean offer(E e) {
return add(e);
}
双端队列操作：
/**
* 将指定的元素插入队列，从头部插入
* @param e
* @return
*/
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;
}
/**
* 获取并移除队列的第一个节点
* @since 1.6
*/
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);
}
/**
* 队列中添加节点，从头部添加
*/
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;
}
9.其他方法
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
/**
* 检验位置是否合法（大于等于0小于等于节点的个数）
*/
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
/**
* 错误信息
*/
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
/**
* 检查索引是否合法
* @param index
*/
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 检查位置是否合法
* @param index
*/
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 链表的大小
*/
public int size() {
return size;
}
/**
* 克隆方法
*/
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;
/**
* 序列化
*/
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);
}
/**
* 反序列化
*/
@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());
}
总结：
（1）LinkedList基于双向链表实现，插入删除效率高，同时也可以作为栈、队列、双端队列来使用。
（2）LinkedList是非线程安全的。
（3）LinkedList中的元素可以为null。
（4）实现了Serializable、Cloneable接口，能被克隆和实例化。
参考：