概述
LinkedList 是线程不安全的,允许元素为null的双向链表。
其底层数据结构是链表,它实现List, Deque, Cloneable, java.io.Serializable接口,因为实现了Deque接口,所以也可以作为一个双端队列。和ArrayList相比较因为没有实现RandomAccess所以它以下标随机访问数据比较慢。
因为底层是链表实现的,所以在增加和删除时只修改指针就可以了,所以时间效率高,也不需要扩容,所以空间效率比arraylist(数组实现)高。
缺点就是当随机访问元素时,它的时间效率会比较低,虽然通过下标获取某个node节点时会根据index处于前半段还是后半段来选择从前遍历查询还是从后面遍历查询(双向链表)但是随着链表长度的增大,查找时间还是会稍长。
下面看一下源码
节点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; // 前一节点
}
}
add
插入单个节点
public boolean add(E e) {
linkLast(e);
return true;
}
默认是在链表尾部插入数据
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++;
}
指定索引处插入节点
如果下标是链表的长度则直接调用在尾部插入的方法,否则才会调用中间插入的方法,这样可以提升效率
其实就是一个双向链表插入元素修改指针的过程
public void add(int index, E element) {
checkPositionIndex(index);//检查下标是否越界
if (index == size)
//在尾节点后插入
linkLast(element);
else
//在中间插入
linkBefore(element, node(index));
}
//在succ节点前,插入一个新节点e
void linkBefore(E e, Node<E> succ) {
//保存后置节点的前置节点
final Node<E> pred = succ.prev;
//以前置和后置节点和元素值e 构建一个新节点
final Node<E> newNode = new Node<>(pred, e, succ);
//新节点new是原节点succ的前置节点
succ.prev = newNode;
if (pred == null)//如果之前的前置节点是空,说明succ是原头结点。所以新节点是现在的头结点
first = newNode;
else//否则构建前置节点的后置节点为new
pred.next = newNode;
size++;//修改数量
modCount++;//修改modCount
}
addAll 在尾部批量增加
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);//以size为插入下标,插入集合c中所有元素
}
//以index为插入下标,插入集合c中所有元素
public boolean addAll(int index, Collection<? extends E> c) {
//检查索引是否处于 [0,size] 闭区间
checkPositionIndex(index);
//拿到目标集合数组
Object[] a = c.toArray();
//新增元素的数量
int numNew = a.length;
//如果新增元素数量为0,则不增加,并返回false
if (numNew == 0)
return false;
// 定义index节点的前置节点,后置节点
Node<E> pred, succ;
//在链表尾部追加数据
if (index == size) {
succ = null; //size节点(队尾)的后置节点一定是null
pred = last;//前置节点是队尾
} else {
succ = node(index);//取出index节点,作为后置节点
pred = succ.prev; //前置节点是,index节点的前一个节点
}
//链表批量增加,是靠for循环遍历原数组,依次执行插入节点操作。对比ArrayList是通过System.arraycopy完成批量增加的
for (Object o : a) {//遍历要添加的节点。
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);//以前置节点 和 元素值e,构建new一个新节点,
if (pred == null) //如果前置节点是空,说明是头结点
first = newNode;
else//否则 前置节点的后置节点设置为新节点
pred.next = newNode;
pred = newNode;//步进,当前的节点为前置节点了,为下次添加节点做准备
}
if (succ == null) {//循环结束后,判断,如果后置节点是null。 说明此时是在队尾append的。
last = pred; //则设置尾节点
} else {
pred.next = succ; // 否则是在队中插入的节点 ,更新前置节点 后置节点
succ.prev = pred; //更新后置节点的前置节点
}
size += numNew; // 修改数量size
modCount++; //修改modCount
return true;
}
根据index查询node(这里包含着开头说的折半查询)
如果位于前半段则从头开始查询,如果位于后半段则从尾部开始查询
//根据index 查询出Node,
Node<E> node(int 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;
}
}
删 remove
删除指定下标节点
public E remove(int index) {
checkElementIndex(index);//检查是否越界 下标[0,size)
return unlink(node(index));//从链表上删除某节点
}
/从链表上删除x节点
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++; //修改modCount
return element; //返回取出的元素值
}
指定元素删除
//考虑 null元素分情况遍历
public boolean remove(Object o) {
if (o == null) {//如果要删除的是null节点
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
//其中的unlink方法上文已经讲过
改 set
public E set(int index, E element) {
// 检查索引是否越界
checkElementIndex(index);
// 取出旧值
Node<E> x = node(index);
// 保存旧值
E oldVal = x.item;
// 新值覆盖旧值
x.item = element;
// 返回旧值
return oldVal;
}
查 get
public E get(int index) {
// 检查索引是否越界
checkElementIndex(index);
// 用node方法取出节点值
return node(index).item;
}
//node方法刚刚说过,可以回去看一下
toArray 方法
public Object[] toArray() {
// new 出一个新的数组,遍历链表将元素存到数组中返回数组
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
总结
- 链表批量增加,是靠for循环遍历原数组,依次执行插入节点操作。对比ArrayList是通过System.arraycopy完成批量增加的。增加一定会修改modCount。
- 通过下标获取某个node 的时候,(add select),会根据index处于前半段还是后半段 进行一个折半,以提升查询效率
- 删也一定会修改modCount。 按下标删,也是先根据index找到Node,然后去链表上unlink掉这个Node。 按元素删,会先去遍历链表寻找是否有该Node,如果有,去链表上unlink掉这个Node。
- 改也是先根据index找到Node,然后替换值。改不修改modCount。
- 查本身就是根据index找到Node。
- 在1.6之前是双向循环链表,1.7变成双向链表(为了提升效率)