LinkedList源码学习
一.LinkedList与ArrayList的异同
1.相同点：
- ArrayList、LinkedList都是单列集合中List接口的实现类，直接或间接继承了AbstractList类
- 他们都是存取、允许重复、可有多个null值，插入有序
- 都是线程不安全的
2.不同点：
-
ArrayList的实现是基于动态数组，在内存中分配连续的空间
LinkedList的底层数据结构是双向链表
-
ArrayList查询快，增删慢
LinkedList查询慢、增删快
-
LinkedList继承了Deque接口，所以LinkedList还实现了Deque接口的特有方法。
-
在增加操作时，ArrayList通过System.arraycopy完成批量增加的
LinkedList通过依次加入结点做到的
二.源码部分
1.基本属性
**AbstractSequentialList 继承自 AbstractList，是 LinkedList 的父类，是 List 接口 的简化版实现。简化在 AbstractSequentialList 只支持按次序访问，而不像 AbstractList 那样支持随机访问。
List 的数据结构就是一个序列，存储内容时直接在内存中开辟一块连续的空间，然后将空间地址与索引对应。
Deque 表示双端队列。双端队列是在两端都可以进行插入和删除的队列。Deque是一个比Stack和Queue功能更强大的接口，它同时实现了栈和队列的功能。ArrayDeque和LinkeList实现了Deque接口。
Cloneable接口 是一个标记接口,也就是没有任何内容
Serializable接口 是启用其序列化功能的接口。实现java.io.Serializable 接口的类是可序列化的。没有实现此接口的类将不能使它们的任意状态被序列化或逆序列化。
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable {
//transient关键字为类型修饰符，英文本意为“短暂的”，在对象序列化过程中，标记了transient的变量不会被序列化。
transient int size;
//头节点
transient LinkedList.Node<E> first;
//尾节点
transient LinkedList.Node<E> last;
//数字后面加上的L表示这是一个long值。 通过这种方式来解决不同的版本之间的串行话问题
private static final long serialVersionUID = 876323262645176354L;
2.Node
//私有静态内部类
private static class Node<E> {
//节点值
E item;
//后继结点
LinkedList.Node<E> next;
//前驱结点
LinkedList.Node<E> prev;
//有参构造方法
Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
3.构造函数
/**
* 构造函数
*1.无参构造函数LinkedList()
* 2.有参构造函数
* 2.1LinkedList(Collection<? extends E> c)
* 2.2linkFirst(E e)
*/
//无参构造，size为0
public LinkedList() {
this.size = 0;
}
//将已有元素的集合Collection 的实例添加到 LinkedList 中，调用的是 addAll() 方法
public LinkedList(Collection<? extends E> c) {
this();
this.addAll(c);
}
4.add方法
- boolean addAll(Collection<? extends E> c)
//将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(Collection<? extends E> c) {
return this.addAll(this.size, c);
}
-
boolean addAll(int index, Collection<? extends E> c)
//将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。 public boolean addAll(int index, Collection<? extends E> c) { //调用方法，不正确则将抛出异常 this.checkPositionIndex(index); //将list直接转为Object[] 数组 Object[] a = c.toArray(); //数组a的长度 int numNew = a.length; //如果长度为0，则返回失败 if (numNew == 0) { return false; } else { //要添加位置的前驱结点 LinkedList.Node pred; //添加位置的结点，index号 LinkedList.Node succ; //在链表后面插入结点 if (index == this.size) { succ = null; pred = this.last; } else { //node（）方法返回index结点 succ = this.node(index); //前驱结点则为succ的前驱结点 pred = succ.prev; } Object[] var7 = a; int var8 = a.length; //遍历a.length次数组 for(int var9 = 0; var9 < var8; ++var9) { //将数组中的值赋给o Object o = var7[var9]; //通过有参构造函数的方法新建结点，前驱结点为：pred, 值为o, 后继结点为null LinkedList.Node<E> newNode = new LinkedList.Node(pred, o, (LinkedList.Node)null); //如果添加位置为第一个位置 if (pred == null) { //直接将first指向新的结点 this.first = newNode; } else { //如果不为第一个位置，则将前驱结点的next指向新结点 pred.next = newNode; } //pred指向新的结点，等待下个结点顺序插入 pred = newNode; } //如果插入位置为尾节点 if (succ == null) { //将last指向目前链表的尾节点 this.last = pred; } else { //将本来在index位置的结点添加在链表上 pred.next = succ; succ.prev = pred; } //链表的大小加上集合的长度 this.size += numNew; //增加链表修改次数 ++this.modCount; return true; } }
5.remove方法
- public E removeFirst()
//删除并返回第一个元素。
public E removeFirst() {
//取到第一个结点的
LinkedList.Node<E> f = this.first;
//如果为空，则抛出异常
if (f == null) {
throw new NoSuchElementException();
} else {
//删除第一个结点
return this.unlinkFirst(f);
}
}
//删除首结点
private E unlinkFirst(LinkedList.Node<E> f) {
//先将数据保存起来
E element = f.item;
//先将首结点的后一个结点保存起来
LinkedList.Node<E> next = f.next;
//f = null
f.item = null;
f.next = null;
//首结点变成要删除结点的后一个结点
this.first = next;
//如果只有一个结点，即首结点没有后继节点，则将
if (next == null) {
this.last = null;
} else {
//next结点则为新的首结点
next.prev = null;
}
//size - 1
--this.size;
//增加链表修改次数
++this.modCount;
//返回首结点的数值
return element;
}
public boolean remove(Object o)
//删除某一元素，返回是否成功，成功为 true，失败为 false。
public boolean remove(Object o) {
LinkedList.Node x;
//如果实参为null，则将值为null的都遍历删除
if (o == null) {
for(x = this.first; x != null; x = x.next) {
if (x.item == null) {
this.unlink(x);
return true;
}
}
} else {
for(x = this.first; x != null; x = x.next) {
if (o.equals(x.item)) {
this.unlink(x);
return true;
}
}
}
return false;
}
//删除参数结点
E unlink(LinkedList.Node<E> x) {
E element = x.item;
//保存前驱和后继结点
LinkedList.Node<E> next = x.next;
LinkedList.Node<E> prev = x.prev;
//如果要删除的结点为首结点
if (prev == null) {
this.first = next;
} else {
//若删除结点有后继结点，则将其指向要删除结点的后继结点
prev.next = next;
//将x设孔
x.prev = null;
}
//如若要删除的结点为最后一个结点
if (next == null) {
//last指针指向删除结点的前一个结点
this.last = prev;
} else {
//否则，将要删除结点的后继结点的前驱结点指向要删除结点的前驱结点
next.prev = prev;
//将x设孔
x.next = null;
}
//将x设孔
x.item = null;
//size也 - 1
--this.size;
++this.modCount;
//返回被删除结点的数据
return element;
}
- public E remove(int index)
//删除指定位置的元素。
public E remove(int index) {
//同样的index检查
this.checkElementIndex(index);
//先用node方法找到目标结点，传参到unlink方法中删除
return this.unlink(this.node(index));
}
6.get、set方法
- public E get(int index)
//返回指定位置的元素。
public E get(int index) {
//与addall相同，添加指定位置时就检查是否在范围内
this.checkElementIndex(index);
//调用node方法，返回index结点的存储值
return this.node(index).item;
}
- public E getFirst()
//返回第一个元素。
public E getFirst() {
//获取首结点
LinkedList.Node<E> f = this.first;
//若为空，则抛出异常
if (f == null) {
throw new NoSuchElementException();
} else {
//返回数据
return f.item;
}
}
-
public E set(int index, E element)
//设置指定位置的元素 public E set(int index, E element) { //检查index是否合法 this.checkElementIndex(index); //新建临时结点 x 存储index结点 LinkedList.Node<E> x = this.node(index); //将旧的index结点的值保存起来 E oldVal = x.item; //重新为其赋值 x.item = element; //返回旧的值 return oldVal; }
7.LinkedList.Node node(int index)方法
//为add，get等操作的提供了查找并返回结点的功能
LinkedList.Node<E> node(int index) {
LinkedList.Node x;
int i;
//位移运算符大于小于操作
//当要查找的index小于size的一半，x指向首结点
if (index < this.size >> 1) {
x = this.first;
//遍历index - 1次，找到index的位置
for(i = 0; i < index; ++i) {
x = x.next;
}
//返回index结点
return x;
} else {
//如果index的值在链表的后半部
//x = 尾结点，从后面开始遍历
x = this.last;
//遍历到index的前一个结点
for(i = this.size - 1; i > index; --i) {
x = x.prev;
}
return x;
}
}
三.总结
- 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。
- 头尾和已知节点的插入和删除时间复杂度都是o(1)
- 在增加，查找，删除操作的时候通过node（index）找到并返回目标结点
