LinkedList 源码解析
JDK位置:java.util.LinkedList
数据结构:双向链表 (查找只需检查一半,从头或从尾开始搜索)
特点:增删快,查找慢(它的特点刚好和ArrayList 相反)
适用场景:适用于对集合中的元素做大量的增删操作的场景 。
链表(linked list) 是由一个个的node结点组成,每个node结点中包含两项数据:
1.指针域(单链表的指针域是指存储指向下一个node节点对象的引用(Java中为引用(Java中引用和指针并不是同一物,但是在初入学习中可以近似看做就是指针),C/C++中为指针))
2.数据域(数据存储的地方,数据的载体)
双向链表则一个节点包含三项:(指针域包含两个,我称为前指针和后指针)指向上一个节点指针、指向下一个节点指针、数据域。
注:
“结” 和“节”都是一会事儿,出现歧义本就是node翻译的问题,有人称“结”,有人称“节”,这都是存在的,不过这都不重要,只需要清楚说的是同一回事儿。所以,在本文中我将链表的前和尾结点用“结”表示,便于我在源码中更清楚的理解,中间的节点都是用“节”称呼,总之这个两都是指的是node。前继节点:当前节点的前指针指向的上一个节点
后继节点:当前节点的后指针指向的下一个节点
1.构造器
// 无参构造器(不传入一个指定列表)
public LinkedList() {
}
// 有参构造器(传入一个指定列表)
public LinkedList(Collection<? extends E> c) {
this();
addAll(c); // 添加方法
}
2.成员变量
transient int size = 0; // 链表的长度,节点个数
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first; // 记录头结点(前指针为空)
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last; // 记录尾结点(后指针点为空)
注:
每一对链表进行修改时(增加、删除、替换等使节点元素发生改变)都要对头结点和尾结点进行更新(也就是该方法中都要考虑是否更改头尾结点),否则在进行链表查询和其他的修改操作时将会与预期结果相悖。当尾结点lastnull时,意味着firstnull。
3.节点类
// 节点声明为私有内部类
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;
}
}
4.插入方法
/** Appends the specified element to the end of this list. */
// 默认在尾结点后添加;E是泛型,e作为数据对象参数传入
public boolean add(E e) { // 添加成功返回true
linkLast(e);
return true;
}
/** Links e as last element. */
// 在链表末尾添加一个节点,使该节点成为新的尾结点。
void linkLast(E e) {
// 将旧的尾结点保存到 l 中,并使 l 的值不能变( l 是Node引用类型,保存的是last的引用),并将其作为即将创建的新节点的前继节点
final Node<E> l = last;
// 创建一个新节点,并将旧尾节点的地址值(地址值不太准确,引用),也就是 l 中保存的引用作为前指针、e作为数据,设后指针为null,创建一个Node对象
final Node<E> newNode = new Node<>(l, e, null);
// 更新链表的尾结点
last = newNode;
/* 判断链表中是否存在元素节点,如果 l 为null则意味则当前链表没有节点,新创建的节点就是第一个节点,并使newNode作为头结点。此处不需要单独设头结点的前指针为null,在当 l 为空时,创键newNode对象时调用的构造器中 l = null,也就是该节点的前指针为null。否则newNode的前继节点的后指针指向newNode。
*/
if (l == null)
first = newNode;
else
l.next = newNode;
size++; // 节点创建成功后,链表长度 + 1
// 该参数表示链表的操作次数;单纯就链表来说并不重要,它是继承的AbstractList,与迭代器相关
modCount++;
}
/** Inserts the specified element at the specified position in this list.*/
// 指定元素位置添加节点
public void add(int index, E element) {
// 检查索引是否越界
checkPositionIndex(index);
/* 如果index == size,说明是在链表的末尾处添加一个节点(也就是添加为结点)
如果index != size,说明是在链表的中间添加一个节点,调用linkBefore,传入参数即可
*/
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
/** Inserts element e before non-null Node succ.
存在元素节点succ,且在succ(此节点可以为任意节点-头结点、中间节点、尾结点)之前插入元素节点(也就是在链表的中间或最前面插入元素节点)
succ就是index索引指向的节点
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
// 将succ的前指针的引用保存在一个Node类型pred中(该pred指向succ的前继节点)
final Node<E> pred = succ.prev;
// 创建新节点,该节点的前指针指向succ的前继节点,数据域保存传入的数据,后指针保存succ的地址引用(指向succ)
final Node<E> newNode = new Node<>(pred, e, succ);
// 并将succ的前指针指向创建的新节点,使新节点成为succ新的前继节点
succ.prev = newNode;
// 判断succ的是否是头结点,如果是,那么插入的新节点将取代succ成为新的头结点;
if (pred == null)
first = newNode;
else
// 如果不是,那么原先succ的前继节点就需要指向创建的新节点
pred.next = newNode;
size++;
modCount++;
}
5.检查索引是否越界
// 定义为私有,只允许当前类调用;如果越界直接抛出IndexOutOfBoundsException异常
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 判断索引值是否在有效范围0~size(链表长度)内
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
6.删除方法
/**
* Retrieves and removes the head (first element) of this list.
* 默认删除头结点
*/
public E remove() {
return removeFirst();
}
/**
* Removes the element at the specified position in this list. Shifts any
* subsequent elements to the left (subtracts one from their indices).
* Returns the element that was removed from the list.
* 根据索引删除节点
*/
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
* Removes the first occurrence of the specified element from this list,
* if it is present. If this list does not contain the element, it is
* unchanged. More formally, removes the element with the lowest index
* {@code i} such that
* 根据对象删除
*/
public boolean remove(Object o) {
// 对象为空(null)只能用“==”,不能用equals()
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;
}
/**
* Removes and returns the first element from this list.
* 删除头结点并返回
*/
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
// 保存的节点不为空则调用unlinkFirst()
return unlinkFirst(f);
}
/**
* Removes and returns the last element from this list.
* 删除尾结点并返回
*/
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
/** Unlinks non-null node x.
将一个非空节点 x 断开链表(删除节点)
*/
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item; // 将该节点的数据保存在element中
final Node<E> next = x.next; // 将该节点的后指针保存在next中
final Node<E> prev = x.prev; // 将该节点的前指针保存在prev中
// 判断 x 节点是否是头结点,如果是,则将 x 的后继节点设置为头结点;如果不是,则将 x 的前继节点(prev)中的后指针(prev.next)指向 x 的后继节点(next)。并将 x 的前指针设为null
if (prev == null) {
first = next;
// next.prev = null; // (源码中是没有的,再手敲的时候遇见了该问题)这里逻辑上是可以不用加上 x 的后继节点的前指针变为null值。结合两个if-else来思考;一、如果prev==null,那么x它就是头结点,就不是尾结点,所以第二个if-else 会直接执行else ,也就意味着next.prev = null(此时prev为null),二、如果next==null,那么x它就是尾结点,不是头结点,所以第一个if-else 会直接执行else ,也就意味着prec.next = null(此时next为null) 三、x 即是头又是尾结点,意味着链表中只有一个节点 x ,prev,next都等于null,只需更新头尾结点
// 所以从源码中,可以学到很多东西,能够学习大佬的逻辑思维,学习如何将程序简单化,程序的上下部分都是紧密相关的
} else {
prev.next = next;
x.prev = null;
}
// 判断 x 节点是否是尾结点,如果是,则将 x 的前继节点设置为尾结点;如果不是,则将 x 的后继节点(next)中的前指针(next.prev)指向 x 的前继节点(next)。并将 x 的后指针设为null
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
// 请空 x 节点的数据域
x.item = null;
// 链表长度 - 1
size--;
modCount++;
// 返回节点 x 中的数据对象
return element;
}
/**
* Unlinks non-null first node f.
* 删除非空头结点,返回数据e
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
// 将原先的头结点数据域和指针域的数据分别进行保存(头结点为空不用保存和清空)
final E element = f.item;
final Node<E> next = f.next;
// 清空节点
f.item = null;
// 将节点 f 的后指针设为null,变为独立的对象,能加快GC的清理
f.next = null; // help GC
// 将第二个节点变为头结点
first = next;
// 判断链表中是否还有其他节点元素,如果没有则链表为空,将尾结点设为空(已经暗含将头结点设为空);否则将新的头结点的头指针指向空
if (next == null)
last = null; // 更新尾结点
else
next.prev = null;
// 删除链表长度 - 1
size--;
modCount++;
// 返回删除节点的数据域
return element;
}
/**
* Unlinks non-null last node l.
* 删除尾结点 l
*/
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;
// 将节点 f 的后指针设为null,变为独立的对象,能加快GC的清理
l.prev = null; // help GC
// 将倒数第二个节点设为尾结点
last = prev;
// 判断原节点中是否还有其他节点元素。prev == null 意味着链表只有一个节点,删除该节点后,头结点就为空,否则原尾结点的前继节点的后指针指向空。
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
7.根据索引查找元素节点
/** Returns the (non-null) Node at the specified element index.
根据index索引查找元素节点,返回一个非空节点x
*/
Node<E> node(int index) {
// assert isElementIndex(index);
// 双向链表,只需查找链表长度的一半(size/2)
// 如果index小于size/2 则从链表头部开始找,否则从链表尾部开始找
if (index < (size >> 1)) {
// 将头结点复制给一个创建的临时节点x
Node<E> x = first;
// 顺着指针域向后搜索,并将每一节点的后指针赋值给x节点(即最后 x 就是指向位于index节点的引用)。所以遍历时只能遍历到index的前继节点
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
// 将尾结点复制给一个创建的临时节点x
Node<E> x = last;
// 顺着指针域向前搜索,并将每一节点的前指针赋值给x节点(即最后 x 就是指向位于index节点的引用)。所以遍历时只能遍历到index的前后继节点
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
8.查找方法
/**
* Returns the element at the specified position in this list.
* 根据索引查找节点元素
*/
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
/**
* Returns the first element in this list.
* 查询头结点元素
*/
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
/**
* Returns the last element in this list.
* 查询尾结点元素
*/
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
总结
以上便是我最近在学习Java的链表的过程中,去扒的JDK1.8的源码,我不太清楚有没有细节上的变化,我想肯定不会有大的改动。链表的核心原理在这里都有体现,之里只有LinkedList的一些常用方法,其中还有很多不太常见的方法并没有去扒一扒,有兴趣的小伙伴可以自行去看看。在扒了源码后,在自己去模仿着写一个,更加的加深了我的理解,扒源码的过程中一些不太理解和疑惑的地方,在自己写的时候慢慢的解开了,受益颇丰。我建议看完源码后也去写写。