LinkedList源码解析
LinkedList的底层实现
双向链表:由一系列的结点组成,每个结点分为三个部分,一个是存储前继节点地址的指针域,一个是存储数据元素的数据域,最后一个是存储后继结点地址的指针域。
顺便提一下单向链表:由一系列的结点组成,与双向链表不同的是,单向链表没有存储前继结点地址的指针域,其余部分相同。
构造方法
LinkedList的构造方法
空构造方法和带参构造方法
空构造方法就是创建一个空的LinkedList链表,带参数的构造方法就是将参数(Collection c)c中的所有元素循环添加到LinkedList链表中。
添加add()方法
//默认的添加就是添加尾部
public boolean add(E e) {
linkLast(e); //调用了linkLast()方法
return true;
}
//这边看一下linkLast()方法的源码
void linkLast(E e) {//e这个就是add方法中传入的参数
final Node<E> l = last; //定义一个l结点,标识为尾结点(last)
//创建一个e结点,参数l(前继结点) e(新节点) null(后继结点) 形成链子
final Node<E> newNode = new Node<>(l, e, null);
//然后将新的这个结点e赋值给last,也就是此时尾结点为新创建的结点e
last = newNode;
//判断last结点是否为null,为null则说明没有尾结点,也就是说该链表中没有元素
if (l == null)
first = newNode;//为null,那么此时链表的头结点也是新的e结点
else
l.next = newNode;//不为null,那么将之前的尾结点l的后继结点指向新创建的e结点
size++;//链表大小++
modCount++;//链表修改次数++
}
add(int index,E element)方法
指定下标的添加,也就是插入
//add(int index,E element)源码
public void add(int index, E element) {
checkPositionIndex(index); //检查传入的下标是否正确
if (index == size)//判断下标是否等于链表的大小,相等的话就是尾部插入,调用linkLast()方法
linkLast(element);
else
//不相等的时候,调用 linkBefore()方法,并传入你要插入的elemnet元素和当前index位置上的元素
linkBefore(element, node(index));
}
//checkPositionIndex()方法源码
private void checkPositionIndex(int index) {
if (!isPositionIndex(index)) //下标不正确 就抛出IndexOutOfBoundsException异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//linkBefore()方法源码
//传入的两个参数,e要插入的结点,succ链表当前index位置的结点
void linkBefore(E e, Node<E> succ) {
final Node<E> pred = succ.prev;//获取当前index位置结点的前继结点
//创建新节点e,他的前继结点为pred,也就是原位置的前继结点,后继结点为元结点succ
final Node<E> newNode = new Node<>(pred, e, succ);
//将原结点的前继结点指向新创建的结点e
succ.prev = newNode;
//判断succ原结点的前继结点是不是为null
if (pred == null)
//假如没有前继结点,那么说明插入的位置就是头部,将新结点赋值给first,也就是链表的头
first = newNode;
else
//反之,就是将原结点的前继结点的后继结点指向新的结点 形成链子
pred.next = newNode;
size++;//链表大小++
modCount++;//修改次数++
}
//再来看一下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()方法看完了,接下来看看remove()方法
remove()
//不带参数的remove()方法 默认删除头部结点,调用了removeFirst()方法
public E removeFirst() {
final Node<E> f = first;
if (f == null)//判断头结点是否为空,其实就是判断链表是否为空
//为空则抛出NoSuchElementException异常
throw new NoSuchElementException();
//如果有元素存在,那么调用unlinkFirst()方法解开链子
return unlinkFirst(f);
}
//在说unlinkFirst之前先说一下unlink()方法
E unlink(Node<E> x) {
final E element = x.item; //获取x结点的元素
final Node<E> next = x.next; //获取x的后继结点
final Node<E> prev = x.prev; //获取x的前继结点
//判断x的前继结点是否存在
if (prev == null) {
//不存在前继结点的话,将头结点赋值为他的后继结点
first = next;
} else {
//存在前继结点的话,将x的前继结点的后继结点赋值为x的后继结点,然后将x与前继结点的连接断开
prev.next = next;
x.prev = null;
}
//同理判断x的后继结点是否存在 ,这边就不一一细说了
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
//x的前继和后继结点都断开连接后,将x的元素设为null,那么GC就会回收
x.item = null;
size--;//链表大小--
modCount++;//修改此时++
return element;//返回被删除的元素
}
//理解了unlink,那么unlinkFirst 和unlinkLast 就很好理解了
//删除头结点
private E unlinkFirst(Node<E> f) {
final E element = f.item; //获取要删除的元素 最后返回
final Node<E> next = f.next;//获取该元素的后继结点
f.item = null; //将结点的元素置空
f.next = null; // 断开他和后继结点的链子 方便GC回收 help GC
first = next; //将头结点给该结点的后继结点
//判断后继结点是否存在
if (next == null)
//如果没有后继结点 说明该链表中只有一个元素,被删除之后,那么last也设为null
last = null;
else
//反之将该元素的后继结点的前继结点设为null,就是断开和该元素的连接
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;
}
那么之后的removeFirst 和 removeLast就是分别调用了上面的unlinkFirst和unlinkLast方法
接着说一下查询方法get()
//get()方法的源码
public E get(int index) {
checkElementIndex(index); //先调用checkElementIndex()方法检查该下标是否正确
return node(index).item; //这边调用了node方法,并返回内容item
}
//checkElementIndex()方法
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//node()方法
Node<E> node(int index) {
//判断你给的下标是不是小于链表size的一半
if (index < (size >> 1)) {
//如果小于一般 那么就从链表的头结点开始查找
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
//如果大于size的一半,那么久从链表的尾部开始查找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}