LinkedList类源码阅读

一、简介

LinkedList位于java.util包中，也是我们比较常见的集合对象。

LinkedList底层是基于双向链表实现的，适合于插入和删除比较多的场景，查询速度相对来说比较慢，由于需要沿着链表挨个查找。

防止意外对列表的非同步访问: List list = Collections.synchronizedList(new LinkedList(...));

链表是一种物理存储上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，节点可以在运行时动态生成。

单向链表的节点包括两个结构：

存储数据元素的数据域；
存储下一个节点地址的指针域；

双向链表的节点包括三个结构：

存储数据元素的数据域；
存储下一个节点地址的指针域；
存储上一个节点地址的指针域；

二、相关源码

LinkedList继承自AbstractSequentialList抽象类，并且实现了List<E>, Deque<E>, Cloneable, java.io.Serializable接口。

public class LinkedList<E> extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, java.io.Serializable{//...
}

Node节点类

//LinkedList内部一个私有静态类
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;
//指向第一个节点的指针。
transient Node<E> first;//指向最后一个节点的指针。
transient Node<E> last;

构造函数

//构造一个空列表
public LinkedList() {
}//构造一个包含指定元素的列表集合，按照集合返回它们的顺序迭代器。
//c: 要将其元素放入此列表的集合
//如果指定的集合为空,抛出空指针NullPointerException异常
public LinkedList(Collection<? extends E> c) {//调用无参构造this();addAll(c);
}

三、常用API

【a】linkFirst()、linkLast()、linkBefore()、unlinkFirst()、unlinkLast()、unlink()

//链接e作为第一个元素。
private void linkFirst(E e) {final Node<E> f = first;//构造插入的新Node节点对象//prev = null  item = e  next=ffinal Node<E> newNode = new Node<>(null, e, f);//将新节点作为指向第一个节点的指针first = newNode;if (f == null)//如果f为空则新节点就是最后一个节点last = newNode;else//如果f不为空，则f的上一个节点是newNodef.prev = newNode;//链表长度加1size++;modCount++;
}//链接e作为最后一个元素。
void linkLast(E e) {final Node<E> l = last;// 构造新的最后一个节点,所以next为null,prev就是指向原先的最后一个节点// 前面一个节点prev = l 、 数据域item = e、 后面一个节点next = nullfinal Node<E> newNode = new Node<>(l, e, null);//设置新节点作为最后一个节点last = newNode;//判断之前链表是不是为空集合if (l == null)//如果原先最后一个节点为空，则新节点也是第一个节点（头尾都是新节点）first = newNode;else//如果原先最后一个节点不为空，则设置下一个节点是newNodel.next = newNode;//链表长度加1    size++;modCount++;
}//在非空节点succ之前插入元素e
void linkBefore(E e, Node<E> succ) {//首先拿到原先succ的前面一个节点final Node<E> pred = succ.prev;//重新构造 (pred <-- e --> succ) 的新节点final Node<E> newNode = new Node<>(pred, e, succ);//修改原succ节点的前面一个节点为新插入的节点newNodesucc.prev = newNode;if (pred == null)//如果原先succ的前面一个元素为空，也就是新节点newNode充当首节点first = newNode;else//重新指向pred的下一个节点为新节点newNodepred.next = newNode;//链表长度加1size++;modCount++;
}//取消非空的第一个节点f的链接。
private E unlinkFirst(Node<E> f) {// assert f == first && f != null;final E element = f.item;//拿出原先x指向的下一个节点final Node<E> next = f.next;//将item值和下一个节点置空f.item = null;f.next = null; // help GC//将原先x指向的下一个节点变为第一个节点first = next;if (next == null)//原先x指向的下一个节点为空，则将最后一个节点设置为空last = null;else//原先x指向的下一个节点不为空,则将next上一节点设置为空next.prev = null;//链表长度减1    size--;modCount++;//返回原先x的值return element;
}//取消非空最后一个节点l的链接
private E unlinkLast(Node<E> l) {// assert l == last && l != null;//拿到原先l节点的值final E element = l.item;//拿到原先l节点指向的上一个节点final Node<E> prev = l.prev;//将item和上一节点置空l.item = null;l.prev = null; // help GC//将原先l节点指向的上一个节点设置为当前最后一个节点last = prev;if (prev == null)//如果原先l节点指向的上一个节点为空，则将第一个节点设置为空first = null;else//如果原先l节点指向的上一个节点不为空，则将prev下一节点设置为空prev.next = null;//链表长度减1      size--;modCount++;return element;
}//取消非空节点x的链接。
E unlink(Node<E> x) {//x是要删除的节点final E element = x.item;//拿出原先x指向的下一个节点final Node<E> next = x.next;//拿出原先x指向的上一个节点final Node<E> prev = x.prev;//如果删除节点前面一个节点为空if (prev == null) {//头部指向x删除节点的后面一个节点first = next;} else {//如果删除节点前面一个节点不为空，则修改原先上一个节点的下一节点指向prev.next = next;//设置x前面节点为空x.prev = null;}// 假设原先关系如下所示：  x前面一个节点prev,x后面一个节点next//(prev) <-- (x) --> (next)//如果删除节点后面一个节点为空，则prev将作为最后一个节点if (next == null) {last = prev;} else {//如果后面一个节点不为空，则修改原先下一个节点的上一节点指向// (prev) <-- (next)next.prev = prev;// (x) --> (null) : 删除节点x的后继节点为null//设置x后面节点为空x.next = null;}//修改x的值为空x.item = null;//链表长度减1 size--;modCount++;return element;
}

【b】getFirst()、getLast()

//返回列表中的第一个元素。
public E getFirst() {//直接获取LinkedList内部指向第一个节点的指针。final Node<E> f = first;if (f == null)throw new NoSuchElementException();//返回node对应的数据域return f.item;
}//返回列表中的最后一个元素。
public E getLast() {//直接获取LinkedList内部指向最后一个节点的指针。final Node<E> l = last;if (l == null)throw new NoSuchElementException();//返回node对应的数据域   return l.item;
}

【c】removeFirst()、removeLast()

//从列表中删除并返回第一个元素。
public E removeFirst() {//直接获取LinkedList内部指向第一个节点的指针。final Node<E> f = first;if (f == null)throw new NoSuchElementException();//直接调用取消非空的第一个节点链接的方法return unlinkFirst(f);
}//从列表中移除并返回最后一个元素
public E removeLast() {//直接获取LinkedList内部指向最后一个节点的指针。final Node<E> l = last;if (l == null)throw new NoSuchElementException();//直接调用取消非空的最后一个节点链接的方法    return unlinkLast(l);
}

【d】addFirst()、addLast()

//将指定的元素插入此列表的开头
public void addFirst(E e) {linkFirst(e);
}//将指定的元素追加到此列表的末尾。
public void addLast(E e) {linkLast(e);
}

【e】contains()、size()

//如果此列表包含指定的元素，则返回true，否则返回false
public boolean contains(Object o) {return indexOf(o) != -1;
}//返回列表中元素的数目。
public int size() {return size;
}

【f】add()、remove()、addAll()、node()

//将指定的元素追加到此列表的末尾。
public boolean add(E e) {linkLast(e);return true;
}/**
* 从列表中删除指定元素的第一个匹配项，如果它存在。如果此列表不包含该元素，则它包含不变* @param o 元素将从此列表中删除(如果存在)* @return {@code true} 如果此列表包含指定的元素*/
public boolean remove(Object o) {if (o == null) {//需要删除的元素为空时，循环遍历链表挨个比较是否为null,是的话就调用unlink取消非空节点的链接。//从第一个节点开始遍历，知道节点node下一个节点为null，遍历结束for (Node<E> x = first; x != null; x = x.next) {if (x.item == null) {unlink(x);return true;}}} else {//需要删除的元素不为空时，循环遍历使用equals方法判断item是否相等,相等的话就调用unlink取消非空节点的链接。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) {//检查下标是否越界checkPositionIndex(index);//将集合先转换为对象数组Object[] a = c.toArray();//本次需要新增加的元素个数int numNew = a.length;//如果需要增加的元素长度为0，直接返回新增失败falseif (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;elsepred.next = newNode;pred = newNode;}if (succ == null) {last = pred;} else {pred.next = succ;succ.prev = pred;}size += numNew;modCount++;return true;
}//返回指定元素索引处的(非空)节点。
Node<E> node(int index) {// assert isElementIndex(index);//size >> 1 相当于 (size / 2)//如果索引在左半部分的话，从第一个节点开始循环遍历(从前往后找)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;}
}private void checkPositionIndex(int index) {if (!isPositionIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}//检查参数是否在索引范围内，即检查是否越界
private boolean isPositionIndex(int index) {return index >= 0 && index <= size;
}

【g】clear()

//从列表中删除所有元素。调用返回后，列表将为空。
public void clear() {// Clearing all of the links between nodes is "unnecessary", but:// - helps a generational GC if the discarded nodes inhabit//   more than one generation// - is sure to free memory even if there is a reachable Iterator//循环遍历链表，将所有节点的值、前面一个节点、后面一个节点全部置空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;//链表长度更新为0size = 0;modCount++;
}

【h】get()、set()、add()、remove()

//返回列表中指定位置的元素。
public E get(int index) {//检查下标是否越界，越界会抛出IndexOutOfBoundsException异常checkElementIndex(index);//返回指定索引处的(非空)节点。return node(index).item;
}//返回指定元素索引处的(非空)节点。
Node<E> node(int index) {// assert isElementIndex(index);//size >> 1 相当于 (size / 2)//如果索引在左半部分的话，从第一个节点开始循环遍历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;}
}//将列表中指定位置的元素替换为指定元素。
public E set(int index, E element) {//检查下标是否越界，越界会抛出IndexOutOfBoundsException异常checkElementIndex(index);//获取指定下标处的节点元素Node<E> x = node(index);//原先节点处的item值E oldVal = x.item;//直接替换item为新值elementx.item = element;//返回替换前的值return oldVal;
}//将指定元素插入到列表中的指定位置。
public void add(int index, E element) {//检查下标是否越界，越界会抛出IndexOutOfBoundsException异常checkPositionIndex(index);//判断是否在尾部直接插入if (index == size)//如果是在最后一个位置插入元素,则实际上就是链接element作为最后一个元素linkLast(element);else//在非空节点之前插入元素element。linkBefore(element, node(index));
}//删除列表中指定位置的元素。后续元素的索引中减去1
public E remove(int index) {//检查下标是否越界，越界会抛出IndexOutOfBoundsException异常checkElementIndex(index);//获取对应索引的值//然后取消非空节点node(index)的链接return unlink(node(index));
}

【i】indexOf()、lastIndexOf()

//返回指定元素第一次出现的索引,在该列表中，如果该列表不包含该元素，则为-1。
public int indexOf(Object o) {int index = 0;//当o为空的时候，就是循环链表挨个判断是否为null,返回第一个为null的元素的下标if (o == null) {for (Node<E> x = first; x != null; x = x.next) {if (x.item == null)return index;index++;}} else {//当o不为空的时候，就是循环链表拿出item使用equals()方法挨个判断是否相等,返回第一个相等的元素对应的下标for (Node<E> x = first; x != null; x = x.next) {if (o.equals(x.item))return index;index++;}}return -1;
}//返回指定元素最后一次出现的索引。在该列表中，如果该列表不包含该元素，则为-1。
public int lastIndexOf(Object o) {int index = size;//同上indexOf()是正序循环遍历链表，lastIndexOf()则从last最后一个节点开始遍历//比较方法都跟indexOf()一样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;
}

【j】队列的操作相关API

//检索但不删除此列表的头(第一个元素)
public E peek() {final Node<E> f = first;return (f == null) ? null : f.item;
}//检索但不删除此列表的头(第一个元素)
public E element() {return getFirst();
}//检索并删除此列表的头(第一个元素)。
public E poll() {final Node<E> f = first;return (f == null) ? null : unlinkFirst(f);
}//检索并删除此列表的头(第一个元素)。
public E remove() {return removeFirst();
}//将指定的元素添加为此列表的末尾(最后一个元素)。
public boolean offer(E e) {return add(e);
}

【k】双端队列的操作API

//将指定的元素插入此列表的前面。
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;
}//检索并删除列表中的第一个元素，如果该列表为空，则返回{@code null}。
public E pollFirst() {final Node<E> f = first;return (f == null) ? null : unlinkFirst(f);
}//检索并删除列表中的最后一个元素，如果该列表为空，则返回{@code 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();
}

【l】superClone()、clone()

@SuppressWarnings("unchecked")
private LinkedList<E> superClone() {try {return (LinkedList<E>) super.clone();} catch (CloneNotSupportedException e) {throw new InternalError(e);}
}//返回此LinkedList的浅拷贝。
public Object clone() {LinkedList<E> clone = superClone();// Put clone into "virgin" stateclone.first = clone.last = null;clone.size = 0;clone.modCount = 0;//初始化克隆for (Node<E> x = first; x != null; x = x.next)clone.add(x.item);return clone;
}

【m】toArray()

//返回一个包含列表中所有元素的数组
public Object[] toArray() {Object[] result = new Object[size];int i = 0;//循环链表，依次将item的值赋值给数组对应下标的值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;
}

【n】writeObject()、readObject()

//将LinkedList实例的状态保存到一个流中.(也就是说，序列化它)。
private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException {// Write out any hidden serialization magics.defaultWriteObject();// Write out sizes.writeInt(size);// Write out all elements in the proper order.//按适当的顺序写出所有的元素for (Node<E> x = first; x != null; x = x.next)s.writeObject(x.item);
}//从流中重构这个{@code LinkedList}实例(即反序列化它)。
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {// Read in any hidden serialization magics.defaultReadObject();// Read in sizeint size = s.readInt();// Read in all elements in the proper order.//按适当的顺序读取所有元素。for (int i = 0; i < size; i++)linkLast((E)s.readObject());
}