LinkedList
1.LinkedList声明
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable{}
LinkedList和ArrayList一样实现了list接口，RandomAccess，Cloneable，java.io.Serializable接口，LinkedList还继承于AbstractSequentialList和实现了Deque。
- RandomAccess用来当标记，是一种标记接口。用处是当要实现某些算法时，会判断当前类是否实现了RandomAccess接口，会选择不同的算法。
- cloneable其实就是一个标记接口，只有实现这个接口后，然后在类中重写Object中的clone方法，然后通过类调用clone方法才能克隆成功，如果不实现这个接口，则会抛出CloneNotSupportedException(克隆不被支持)异常。
- Serializable 其实就是一个标记接口，标记该类是可以被序列化和反序列化的。
- AbstractSequentialList是双向链表，所以LinkedList也是双向链表
- 实现了Deque，所以LinkedList具有队列的属性，可以当作双端队列使用。
2.LinkedList成员变量
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;
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;
}
}
- size 链表大小
- first 链表头部
- last 链表尾部
- Node是LinkedList的内部类，定义了链表的内部结构，Node的定义可以看出链表是一个双端链表的结构。有next和prev两个节点，一个标识上一个节点，一个标识下一个节点，所以每个链表的数据都存储了上一个节点和下一个节点的信息。
3.LinkedList构造方法
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
LinkedList有两个构造方法，一个用于构造一个空的链表，一个用已有的集合创建链表。具体使用内部的addAll方法，后面会分析。
4.add(E e) 添加方法
public boolean add(E e) {
linkLast(e);
return true;
}
//
void linkLast(E e) {
//取链表的最后一个节点数据赋值为l
final Node<E> l = last;
//生成一个新的节点，上一个节点为l，下节点为null，所以看出这个方法其实是在链表的尾部进行数据添加。
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
//如果原来没有节点，添加的节点为第一个节点
first = newNode;
else
//如果原来有节点数据。原来的最后一个节点数据的下一个节点为新加节点
l.next = newNode;
//添加了一个节点，size++
size++;
modCount++;
}
protected transient int modCount = 0;
public void add(int index, E element) {
//校验链表索引是否越界
checkPositionIndex(index);
if (index == size)
//所以等于链表大小，直接在尾部添加节点
linkLast(element);
else
//不是尾部则在相应位置添加节点
linkBefore(element, node(index));
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
//如果越界抛出异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
Node<E> node(int index) {
// assert isElementIndex(index);
//如果index的大小在前半部分
if (index < (size >> 1)) {
//从前往后循环，得到index所在节点
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
////从后往前循环，得到index所在节点
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;
//获取index节点的前一个节点
final Node<E> pred = succ.prev;
//生成一个新的节点，上一个节点为index所在的前一个节点，后一个节点为index节点
final Node<E> newNode = new Node<>(pred, e, succ);
//index节点的上一个节点为新节点
succ.prev = newNode;
if (pred == null)
//如果index节点的上一个节点为null，插入位置为首节点。
first = newNode;
else
//否则，index的上一个节点的下一个节点为新节点
pred.next = newNode;
//链表大小++
size++;
modCount++;
}
//将集合插入到链表尾部，即开始索引位置为size
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//将集合从指定位置开始插入
public boolean addAll(int index, Collection<? extends E> c) {
//检查index范围
checkPositionIndex(index);
//到集合的数据
Object[] a = c.toArray();
//集合的大小
int numNew = a.length;
//如果集合大小为0直接返回false
if (numNew == 0)
return false;
Node<E> pred, succ;
//如果插入位置为尾部，上一个节点为last，下一个节点为null
if (index == size) {
succ = null;
pred = last;
} else {
//否则，调用node()方法得到index节点为上一个节点，index节点的上一个节点为上一个节点
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;
}
public void addFirst(E e) {
linkFirst(e);
}
//添加头部节点
public void push(E e) {
addFirst(e);
}
//添加头部节点，方法一样的不在一一说明
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
//添加头部节点，和addFirst相比返回了一个boolean
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
public void addLast(E e) {
linkLast(e);
}
//添加尾部节点
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
//添加头部节点，和addLast相比返回了一个boolean
public boolean offer(E e) {
return add(e);
}
上面就是LinkedList的添加数据的方法，从源码可以看出，LinkedList在数据头部或者中部插入数据效率是很高的，把插入位置的上一节点和下一节点的指向的节点数据做修改就行，不需要移动其他数据。
5.get(int index) 检索方法
//调用node(index)方法获取index位置的数据
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//获取首部节点数据，如果链表为空会抛出异常
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
//获取首部节点数据，如果链表为空会抛出异常
public E element() {
return getFirst();
}
//获取首部节点数据，如果链表为空不会抛出异常，直接返回null
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//获取首部节点数据，如果链表为空不会抛出异常，直接返回null
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//获取尾部节点数据，如果链表为空会抛出异常
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
//获取尾部节点数据，如果链表为空不会抛出异常，直接返回null
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
//根据节点数据从前往后查找获取索引位置
public int indexOf(Object o) {
int index = 0;
if (o == null) {
//如果是查找null，从前往后查找直到找到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++;
}
}
//没找到则返回-1
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;
}
//检查链表是否存在某数据，实际是调用的indexOf，返回的不是-1则存在
public boolean contains(Object o) {
return indexOf(o) != -1;
}
上面就是LinkedList的检索数据的方法，从源码可以看出，LinkedList检索数据需要一个个从头部一直往下找，或者从后往前循环查找，效率不高。
6.remove(int index) 删除方法
//删除指定索引的元素
public E remove(int index) {
//检查是否越界
checkElementIndex(index);
//找到索引所在节点数据
return unlink(node(index));
}
//根据数据删除节点
public boolean remove(Object o) {
//linkedlist是可以存储null，所以需要区分，如果为null的话
if (o == null) {
//从前向后遍历
for (Node<E> x = first; x != null; x = x.next) {
//一旦匹配，调用unlink()方法和返回true
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
//从前向后遍历
for (Node<E> x = first; x != null; x = x.next) {
//一旦匹配，调用unlink()方法和返回true
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
//根据数据删除节点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//根据数据删除节点，和remove(Object 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;
}
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;
//如果上一节点为null
if (prev == null) {
//删除头部节点，下一节点设置为新的头部节点
first = next;
} else {
//上一节点的下一节点设置为下一节点
prev.next = next;
//当前节点的上一届点设置为null
x.prev = null;
}
if (next == null) {
//吐过下一节点为null，删除尾部节点，上一届点设置为尾部节点
last = prev;
} else {
//下一节点的上一届点为上一节点
next.prev = prev;
//当前节点的下一节点置为null
x.next = null;
}
//节点数据置为null
x.item = null;
//链表大小--
size--;
modCount++;
//返回节点数据
return element;
}
//删除头节点，如果链表为空抛出异常
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
//删除头节点，如果链表为空抛出异常
public E pop() {
return removeFirst();
}
//删除头节点，如果链表为空返回null
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//删除头节点，如果链表为空返回null
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//删除尾节点，如果链表为空抛出异常
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//删除尾节点，如果链表为空返回null
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
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;
//头节点下一节点置为空，因为头节点的上一个节点也为空，这样操作之后，头节点没有数据也不存在引用，所以java的gc就会对该节点的内存空间进行回收。
f.next = null; // help GC
//头节点的下一个节点置为头节点
first = next;
if (next == null)
//如果下一个节点为空，尾节点也置为空，链表为空
last = null;
else
//新的头节点的上一节点置为空
next.prev = null;
//链表大小--
size--;
modCount++;
//返回删除的节点数据
return element;
}
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;
}
//清空链表
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;
//大小置为0
size = 0;
modCount++;
}
//修改所以位置的数据，找到索引位置的节点，新数据替换老数据，返回老数据
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
上面就是LinkedList的删除数据的方法，从源码可以看出，LinkedList删除数据也只需要关注上一节点和下一节点的变动，所以效率也是很高的。
7.iterator() 迭代器
//调用listIterator()
public Iterator<E> iterator() {
return listIterator();
}
//调用listIterator()
public ListIterator<E> listIterator() {
return listIterator(0);
}
//调用ListItr()
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;//保存当前modCount，确保fail-fast机制
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);//得到当前索引指向的next节点
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
//获取下一个节点
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
//获取前一个节点，将next节点向前移
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
在ListIterator的构造器中，得到了当前位置的节点，就是变量next。next()方法返回当前节点的值并将next指向其下一个节点，previous()方法返回当前节点的上一个节点的值并将next节点指向其上一节点。由于Node是一个双端节点，所以这儿用了一个节点就可以实现从前向后迭代和从后向前迭代。另外在ListIterator初始时，exceptedModCount保存了当前的modCount，如果在迭代期间，有操作改变了链表的底层结构，那么再操作迭代器的方法时将会抛出ConcurrentModificationException，这就是每次链表操作都会有modCount++操作的原因。
8.总结
- LinkedList是基于双端链表的List，其内部的实现源于对链表的操作，类似于c的指针操作，所以适用于频繁增加、删除的情况，效率会很高，但查找数据需要从起始或者结尾开始循环，效率没有arrayList高。
- 该类没有任何同步机制，所以不是线程安全的。
- 由于LinkedList实现了Queue接口，所以LinkedList不止有队列的接口，还有栈的接口，可以使用LinkedList作为队列和栈的实现
