一、简介
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=f
final Node<E> newNode = new Node<>(null, e, f);
//将新节点作为指向第一个节点的指针
first = newNode;
if (f == null)
//如果f为空则新节点就是最后一个节点
last = newNode;
else
//如果f不为空,则f的上一个节点是newNode
f.prev = newNode;
//链表长度加1
size++;
modCount++;
}
//链接e作为最后一个元素。
void linkLast(E e) {
final Node<E> l = last;
// 构造新的最后一个节点,所以next为null,prev就是指向原先的最后一个节点
// 前面一个节点prev = l 、 数据域item = e、 后面一个节点next = null
final Node<E> newNode = new Node<>(l, e, null);
//设置新节点作为最后一个节点
last = newNode;
//判断之前链表是不是为空集合
if (l == null)
//如果原先最后一个节点为空,则新节点也是第一个节点(头尾都是新节点)
first = newNode;
else
//如果原先最后一个节点不为空,则设置下一个节点是newNode
l.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节点的前面一个节点为新插入的节点newNode
succ.prev = newNode;
if (pred == null)
//如果原先succ的前面一个元素为空,也就是新节点newNode充当首节点
first = newNode;
else
//重新指向pred的下一个节点为新节点newNode
pred.next = newNode;
//链表长度加1
size++;
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,直接返回新增失败false
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;
}
//返回指定元素索引处的(非空)节点。
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;
//链表长度更新为0
size = 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为新值element
x.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" state
clone.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 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);
}
//从流中重构这个{@code 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());
}