LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列,它是基于双向链表实现的,是线程不安全的,允许元素为null的双向链表。
变量分析
// 默认元素数量是0
transient int size = 0;
//头结点
transient Node<E> first;
//尾节点
transient Node<E> last;
构造方法分析
//默认是无参构造方法
public LinkedList() {
}
//有参构造,传入一个集合,还是调用无参构造,在将集合添加到链表中
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
添加元素(默认是构造一个空链表)
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
接下来
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index); //检查下标是否合理 index >= 0 && index <= size;
Object[] a = c.toArray();
int numNew = a.length; // 要添加集合的长度
if (numNew == 0) //空集合则添加失败 返回false
return false;
Node<E> pred, succ; //前驱 后继
if (index == size) { //判断要添加的位置是否在链表末尾
succ = null; //在则该集合前驱是原来尾节点,后继指向null
pred = last;
} else {
succ = node(index); //否则则根据下标找到指定节点,该集合后继就是该节点
pred = succ.prev; //前驱则是找出来那个节点原来的前驱节点
}
// 链表批量增加,是靠for循环遍历原数组,依次执行插入节点操作
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
// 前置节点为pred,后置节点为null,当前节点值为e的节点newNode
Node<E> newNode = new Node<>(pred, e, null);
// 如果前置节点为空, 则newNode为头节点,否则为pred的next节点
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
// 循环结束后,如果后置节点是null,说明此时是在队尾追加的
if (succ == null) {
// 设置尾节点
last = pred;
} else {
//否则是在队中插入的节点 ,更新前置节点 后置节点
pred.next = succ;
succ.prev = pred;
}
// 修改数量size
size += numNew;
//修改modCount
modCount++;
return true;
}
根据下标查找指定节点
Node<E> node(int index) {
// assert isElementIndex(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;
}
}
检测index位置是否合法
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
检测index位置是否合法
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
从头部添加元素
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++;
}
从尾部添加,原理相似
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++;
}
在指定节点前添加
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
// 拿到succ的前驱
final Node<E> pred = succ.prev;
// 新new节点:前驱为pred,值为e,后继为succ
final Node<E> newNode = new Node<>(pred, e, succ);
// 将succ的前驱指向当前节点
succ.prev = newNode;
// pred为空,说明此时succ为首节点
if (pred == null)
// 指向当前节点
first = newNode;
else
// 否则,将succ之前的前驱的后继指向当前节点
pred.next = newNode;
size++;
modCount++;
}
从头部删除节点
private E unlinkFirst(Node<E> f) {
//取出头结点和其后继,将其后继指定为新的头结点,原头结点指向null
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
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;
}
删除指定元素
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;
//判断是否为头结点
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;
size--;
modCount++;
return element;
}