一 LinkedList定义
相比ArrayList，LinkedList多实现了一个Deque接口，这是一个双向队列接口，表示两端都可以进行增加和删除操作。
二 字段属性
//链表节点的个数
transient int size = 0;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
指向第一个节点的指针
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
//指向最后一个节点的指针
transient Node<E> last;
这里出现了Node类，这是LinkedList的内部类，其中每一个元素就代表一个 Node 类对象，LinkedList 集合就是由许多个 Node 对象类似于手拉着手构成。
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 是没有初始化链表大小的构造函数，因为链表不像数组，一个定义好的数组是必须要有确定的大小，然后去分配内存空间，而链表不一样，它没有确定的大小，通过指针的移动来指向下一个内存地址的分配。
public LinkedList() {
}
/**
* Constructs a list containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
*
* @param c the collection whose elements are to be placed into this list
* @throws NullPointerException if the specified collection is null
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
四 方法——添加元素：
将指定元素添加到链表头的原理就是该表头元素的指向上一个节点的地址，让添加的元素指向下一个节点的引用指向之前的头元素。
//将指定元素添加到链表头
public void addFirst(E e) {
linkFirst(e);
}
/**
* Links e as first element.
*/
private void linkFirst(E e) {
final Node<E> f = first; //将头节点赋给f
final Node<E> newNode = new Node<>(null, e, f);//new 一个新节点，指向下一个节点的引用为头结点，指向上一个节点的引用为空
first = newNode;//将新节点赋给头结点
if (f == null) //如果之前头结点为空，说明链表为空
last = newNode;//将新节点赋值给最后一个节点，头节点也是尾节点
else
f.prev = newNode;//之前头节点的指向上一个节点指向新节点
size++; //节点数+1
modCount++; //和ArrayList中一样，iterator和listIterator方法返回的迭代器和列表迭代器实现使用。
}
将指定元素添加到链表尾:
调用add和addLast一样，内部都是调用linkLast方法。
//将指定元素添加到链表尾
public boolean add(E e) {
linkLast(e);
return true;
}
//将指定元素添加到链表尾
public void addLast(E e) {
linkLast(e);
}
void linkLast(E e) {
final Node<E> l = last; //将尾节点赋给l
final Node<E> newNode = new Node<>(l, e, null); //创建一个新节点，指向上一个节点指向原尾节点，指向下一个节点为空
last = newNode;//将新节点赋给尾节点
if (l == null) //l为空，说明链表为空
first = newNode; //将新节点也赋给头节点
else
l.next = newNode; //让l的指向下一个节点指向新节点
size++; //节点个数+1
modCount++;
}
将指定的元素插入到链表指定的位置。
//将指定的元素插入此列表中的指定位置
public void add(int index, E element) {
//判断索引 index >= 0 && index <= size中时抛出IndexOutOfBoundsException异常
checkPositionIndex(index);
if (index == size) //如果给定索引等于节点个数，
linkLast(element);//直接将指定元素添加到链表尾部
else
linkBefore(element, node(index));
}
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) { //如果指定的索引在前半部分
Node<E> x = first; //将头节点赋给x
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; //将给定索引位置的节点返回
}
}
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev; //插入节点的上一个节点设为pred
final Node<E> newNode = new Node<>(pred, e, succ);//创建一个节点，值为给定元素，上一个节点引用为pred，下一个节点引用为索引原节点
succ.prev = newNode;//索引原节点上一个节点引用为新节点
if (pred == null)//如果上一个节点为空，说明插入的是头节点
first = newNode; //新节点也赋给头节点
else
pred.next = newNode;//上一节点的下一个节点引用指向新节点
size++;//节点个数+1
modCount++;
}
//判断索引是否超出范围
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//判断索引是否超出范围
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
将按照指定集合的迭代器返回的顺序将指定集合中的所有元素添加到列表。
//按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此列表的末尾。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//将集合 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 集合中添加元素的各种方式，我们发现LinkedList 每次添加元素只是改变元素的上一个指针引用和下一个指针引用，而且没有扩容。，对比于 ArrayList ，需要扩容，而且在中间插入元素时，后面的所有元素都要移动一位，两者插入元素时的效率差异很大。
删除元素：
remove()和removeFirst()移除并且返回第一个元素。
//从此列表中移除并返回第一个元素
public E remove() {
return removeFirst();
}
//从此列表中移除并返回第一个元素
public E removeFirst() {
final Node<E> f = first; //f设为头结点
if (f == null)
throw new NoSuchElementException(); //如果头结点为空，则抛出异常
return unlinkFirst(f);
}
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item; //头节点的值
final Node<E> next = f.next; //next 为头结点的下一个节点
f.item = null; // 将节点的元素以及引用都设为 null，便于垃圾回收
f.next = null; // help GC
first = next;
if (next == null) //如果第二个节点为空（说明当前链表只存在第一个元素）
last = null; //那么尾节点也置为 null
else //如果第二个节点不为空
next.prev = null; //将第二个节点的上一个节点引用置为null
size--; //节点个数-1
modCount++;
return element; 返回头结点的值
}
removeLast()：
//从该列表中删除并返回最后一个元素
public E removeLast() {
final Node<E> l = last;
if (l == null) //如果尾节点为空，表示当前集合为空，抛出异常
throw new NoSuchElementException();
return unlinkLast(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; //将节点的元素以及引用都设为 null，便于垃圾回收
l.prev = null; // help GC
last = prev; //上一个节点设为尾节点
if (prev == null) //上一个节点为空，
first = null; //将头结点也设为null
else
prev.next = null; //如果上一个节点不为空，将上一个的节点指向下一个节点的置为空，表示这个节点现在是尾节点
size--; //节点个数-1
modCount++;
return element;
}
删除指定索引的元素
//删除此列表中指定位置的元素
public E remove(int index) {
checkElementIndex(index); //判断给定索引是否超出范围
return unlink(node(index)); //node(index) 返回该索引对应的节点，但是通过一个指针一个指针从头节点或者尾节点找过去的，所以会比较浪费效率。
}
E unlink(Node<E> x) { //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; //将值置为null，方便GC回收
size--;//节点个数-1
modCount++;
return element;
}
修改元素
public E set(int index, E element) {
checkElementIndex(index); //判断给定索引是否超出范围
Node<E> x = node(index); //获得给定索引对应的节点
E oldVal = x.item;//将给定索引对应的节点的元素值赋给oldVal，方便返回
x.item = element; //将给定元素赋值给该节点
return oldVal;
}
查找元素
//通过给定索引获取值
public E get(int index) {
checkElementIndex(index); //首先判断是否超出了范围
return node(index).item; //通过node(index)方法获取该节点，返回该节点的item值即可
}
//获得头节点的元素值
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;
}
//返回此列表中指定元素第一次出现的索引，如果此列表不包含元素，则返回-1。
public int indexOf(Object o) {
int index = 0;
if (o == null) { //如果查找的元素为null(LinkedList可以允许null值)
for (Node<E> x = first; x != null; x = x.next) { //从头结点开始不断向下一个节点进行遍历
if (x.item == null)
return index;
index++;
}
} else { //如果查找的元素不为null
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1; //找不到就返回 -1
}