参考:https://www.cnblogs.com/gxl1995/p/7edbcaa403c9252b983dc8ef016f190a.html
参考:https://blog.csdn.net/fighterandknight/article/details/61476335
一、概述
LinkedList结构
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
1、LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
2、LinkedList 实现 List 接口,能对它进行队列操作。
3、LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。
4、LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆。
5、LinkedList 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。
6、LinkedList 是非同步的。
transient关键字的作用
序列化:将对象信息转化为二进制信息,便于存储和网络传输
反序列化:将二进制信息恢复成对象信息
HashMap源,有个字段是用transient修饰的,确实没必要对这个modCount字段进行序列化,因为没有意义,modCount主要用于判断HashMap是否被修改
一个对象只要实现了Serilizable接口,这个对象就可以被序列化,添加了transient关键字的属性就不会被序列化
二 、源码分析
1、LinkedList属性
//元素的实际个数
transient int size = 0;
/**
指向第一个节点
* Pointer to first node.
* Invariant[ɪnˈveəriənt]: adj. 无变化的,不变的
(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;
//内部类,用于实现链表
private static class Node<E> {
E item; //存储的元素
Node<E> next; //下一个节点,尾元素的next指向为null
Node<E> prev; //上一个节点,头元素的prev的指向为null
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
2、LinkedList构造方法
/**
* 默认构造方法,size为0,first和last的节点都为空
*/
public LinkedList() {
}
通过一个集合初始化LinkedList,元素顺序有这个集合的迭代器返回顺序决定
public LinkedList(Collection<? extends E> c) {
this();//调用无参构造函数
addAll(c);//添加集合中的所有元素
}
添加指定集合的元素到列表,默认从最后开始添加
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c); //传入当前的节点个数size=0,并将collection对象传递进去
}
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);//检查角标是否越界([0,size])
Object[] a = c.toArray(); //得到元素数组
int numNew = a.length;//要添加集合的长度
if (numNew == 0)//若没有元素要添加,直接返回false
return false;
//pred指定位置的前驱节点,succ指定位置的节点
Node<E> pred, succ;
if (index == size) {
//两种情况:1.要添加的list为空,2.添加到list的末尾
//这时:当前节点后一个节点初始化为null,前一个节点为尾节点
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)
//如果list表为空
first = newNode;//若果前节点为null,则新加的节点为首节点
else
//如果存在前节点,前节点会向后指向新加的节点[-->]
pred.next = newNode;
//新加的节点成为前一个节点
pred = newNode;
}
//添加集合中的元素完成后,将指定位置后面的元素后移
if (succ == null) {
//如果list为空或者添加到list的末尾,最后添加的节点成为尾节点
last = pred;
} else {
//添加的位置是list中间,将指定位置和指定位置的元素后移
pred.next = succ;
succ.prev = pred;
}
//修改list大小
size += numNew;
modCount++;
return true;
}
3、方法分析
1、 add(E e)方法
该方法直接将新增的元素放置链表的最后面,然后链表的长度(size)加1,修改的次数(modCount)加1
/**
* 增加指定元素到list的末尾
*/
public boolean add(E e) {
linkLast(e);
return true;
}
//使用对应参数作为尾节点
void linkLast(E e) {
//将新加节点的前驱指向last节点(<--)
final Node<E> l = last;
//创建节点(前驱是last节点,元素为e,后继为null节点)
final Node<E> newNode = new Node<>(l, e, null);
//将last节点修改为指向新节点
last = newNode;
//判断新节点的前节点(就是以前的last节点)是不是为空
if (l == null)
//如果新节点的前节点为空,
// 说明这个list集合是一个空集合,这个新加节点是添加的第一个节点,
//将first节点修改为指向新节点
first = newNode;
else
//如果新节点的前节点不为空
//说明这个list集合有元素
//将前节点的后继修改为新节点(-->)
l.next = newNode;
size++;
modCount++;
}
add(E e)方法
在指定节点前插入节点
1、检查索引是否越界
2、如果指定位置是最后,则添加到链表最后
3、如果指定位置不是最后,则添加到指定位置之前
public void add(int index, E element) {
checkPositionIndex(index);//检查位置的角标,[0,size]
if (index == size) //如果指定位置为最后,则添加到链表最后
linkLast(element);
else
//如果指定位置不是最后,则添加到指定位置前
linkBefore(element, node(index));
}
//在指定节点前插入节点,节点succ不能为空
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;//取出指定节点的前驱节点
//新建一个以指定节点为后继节点,当指定节点的前驱节点为前驱节点的节点
final Node<E> newNode = new Node<>(pred, e, succ);
//修改指定节点的前驱为新节点
succ.prev = newNode;
if (pred == null)
//如果指定节点为first节点
first = newNode;//将first节点修改为新节点
else
//将指定节点的前节点指向新节点
pred.next = newNode;
size++;
modCount++;
}
2、remove()方法
remove方法本质调用的还是removeFirst方法
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
//删除首节点并返回删除前首节点的值,首节点不为空,内部使用
private E unlinkFirst(Node<E> f) {
// 断言 f == first && f != null;
final E element = f.item;//取出首节点元素
final Node<E> next = f.next;//得到下一个节点
f.item = null;//将首节点元素置空
f.next = null; // 将节点后继置空,帮助回收
first = next;//首节点的下一个节点成为新的首节点
if (next == null)
//这判断,如果链表中就有一个节点,首节点和尾节点都指向这个节点的话
//首节点的下一个节点为空
last = null; //如果不存在下一个节点,则首尾都为null(空表)
else
next.prev = null;//如果存在下一个节点,那它向前指向null
size--;
modCount++;
return element;
}
removeLast方法
/**
* 删除和返回链表中的最后一个元素
*/
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//删除尾节点并返回删除前尾节点的值,为节点不为空,内部使用
private E unlinkLast(Node<E> l) {
// 断言 l == last && l != null;
final E element = l.item;//获取值
final Node<E> prev = l.prev;//获取尾节点前一个节点
l.item = null;
l.prev = null; // 便于垃圾回收器清理
last = prev;//前一个节点成为新的尾节点
if (prev == null)
//这说明链表中只有一个节点(first和last都指向它)
first = null;//如果前一个节点不存在,则首尾都为null(空表)
else
prev.next = null;//如果前一个节点存在,先后指向null
size--;
modCount++;
return element;
}
remove(int index)方法
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
/**
* 返回指定索引的节点
*/
Node<E> node(int index) {
// 判断位置在链表前半段或者是后半段
if (index < (size >> 1)) {//如果index在链表的前半段
Node<E> x = first;//第一个节点
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {//如果index在链表的后半段
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//删除不为空的节点x
E unlink(Node<E> x) {
// 断言 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;
}