定义
LinkedList：一中可以在任何位置进行高效地插入和删除操作的有序序列。
LinkedList 数据结构
LinkedList 结构如下：
transient int size = 0; //list大小
transient Node<E> first;//第一个元素
transient Node<E> last; //最后一个元素
//节点数据结构
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;
}
}
Node 不仅存储当前节点的值还存储了下一个和上一个节点的引用，所以LinkedList 是一个双向链表。
继承关系
可以看到LinkedList 继承自AbstractSequentialList，并且实现了 List 和 Deque(双端队列)，所以LinkedList 不仅具有 List的所有功能，还具体队列的特性。
基本操作
构造方法
LinkedList 的构造方法有两个，如下：
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
一个空参的构造方法
一个 Collection 对象，并且 Collection 存储的内容要继承自 LinkedList 声明的数据类型。
Collection
可以看到Collection 是一个实现 Iterable 的接口。
增加的基本方法
LinkedList 中提供了几个基本的方法，后面的增加操作都是基于下面的方法实现的
linkFirst
/**
* 将e作为第一个元素
*/
private void linkFirst(E e) {
//将first 赋值给f，first是链表的第一个节点
final Node<E> f = first;
//新建一个节点接收e，上一个节点pre为null，下一个节点指向f(第一个元素)
final Node<E> newNode = new Node<>(null, e, f);
//将新结点赋值给first
first = newNode;
//如果是空表，f等于null
if (f == null)
last = newNode;//空表时newNode为第一个元素，此时first和last为同一个元素
else
f.prev = newNode;//不是空表时，将之前的第一个元素f的上一个节点指向newNode(现在的first)
//长度加1
size++;
modCount++;
}
linkLast
/**
* 将e作为最后一个元素
*/
void linkLast(E e) {
//将最后一个元素last赋值给l
final Node<E> l = last;
//新建一个节点接收e,该节点的上一个元素指向l(最后一个节点),下一个节点null
final Node<E> newNode = new Node<>(l, e, null);
//将newNode 赋值给最后一个节点
last = newNode;
//如果l为空，表示是个空表，newNode为第一个元素也是最后一个元素
if (l == null)
first = newNode;
else
l.next = newNode;//将之前的最后一个元素的下一个节点指向新的last
//list大小加1
size++;
modCount++;
}
linkBefore
/**
* 在非空节点 succ 前插入e
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
//succ前面的节点
final Node<E> pred = succ.prev;
//新建一个节点接收e，上个节点的索引指向pred，下个节点指向succ
final Node<E> newNode = new Node<>(pred, e, succ);
//将succ直接前趋指向newNode
succ.prev = newNode;
//pred 为null 表示 succ为第一个元素
if (pred == null)
first = newNode;
else
pred.next = newNode;//将上个节点的next指向newNode
//列表大小加1
size++;
modCount++;
}
增加：add
1、 add(e) 添加到队尾
public boolean add(E e) {
linkLast(e);
return true;
}
可以看到，add()方法调用linkLast() 将e保存到最后一个节点
2、add(1,e) 添加到指定位置
public void add(int index, E element) {
//校验index是否越界，越界抛出IndexOutOfBoundsException
checkPositionIndex(index);
//如果index == size则插入到最后一个
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
node(int index)源码如下：
/**
* 返回指定元素的非空节点
*/
Node<E> node(int index) {
// assert isElementIndex(index);
//因为LinkedList 是链表，所以只能通过遍历获得指定元素处的节点
//如果index 小于 (int)size/2，从头循环。
//目的为了节约循环次数
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
//如果index在size的后半段位置，则从队尾开始循环
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
3、addAll()
//添加到尾部
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//添加到指定部位
public boolean addAll(int index, Collection<? extends E> c) {
//校验index是否越界
checkPositionIndex(index);
//将c转换成数组
Object[] a = c.toArray();
//数组的长度
int numNew = a.length;
//长度为0则返回
if (numNew == 0)
return false;
//声明两个节点
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
//获得指定位置的节点
succ = node(index);
pred = succ.prev;
}
//循环插入a数组元素
for (Object o : a) {
E e = (E) o;
//新建节点接收e,并设置上个节点的索引pred
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
//将该节点赋值给pred
pred = newNode;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
//大小增加
size += numNew;
modCount++;
return true;
}
4、addFirst()，addLast()
public void addFirst(E e) {
linkFirst(e);
}
public void addLast(E e) {
linkLast(e);
}
可以看到其实就是调用基本的方法linkFirst，linkLast。
get
1、getFirst，getLast。直接返回first和last
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
2、get(int index)
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
获得指定位置的值，先校验是否index是否越界，然后调用node(int index)方法获得指定位置的节点node对象。然后获得item值
删除
删除某个节点 unlink
/**
* 断开非空节点 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;
//下面做了就是将prev和next相连， 即
next.prev = prev， prev.next = next
//以及头结点，尾结点的特殊处理
//prev为null 说明是头结点
if (prev == null) {
first = next;
} else {
prev.next = next;
//释放引用
x.prev = null;
}
//next为null 说明释放的是尾结点
if (next == null) {
last = prev;
} else {
next.prev = prev;
//释放引用
x.next = null;
}
x.item = null;
//list大小减1
size--;
modCount++;
return element;
}
断开x节点，其实就是将x节点从链中移除，需要：
- 将x节点的上一个节点prev的next指向x节点下一个节点next，即 prev.next = next
- 将x节点的下一个节点next的prev指向x节点的上一个节点prev，即 next.prev = prev
remove(Object o)和remove(int index)
了解了unlink(Node<E> x)方法的工作原理后，下面remove(int index)和remove(Object o)就简单了
//移除index位置的节点
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
//移除节点值为Object的节点
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 {
//移除节点值为o的节点
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
unlinkFirst(Node f)和unlinkLast(Node l)
这两个方法分别将头结点和尾结点与链表断开(删除)。
1、unlinkFirst()，将头结点与链表断开连接：
- 如果该链表就一个元素，将 first 和 next置空
- 如果该链表不止一个元素，将first.next节点赋值给first，赋值以后将first.prev置空
- 置空该节点
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.next = null; // help GC
first = next;
//next==null表示只有一个元素的节点
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
2、unlinkLast，将尾结点与链表断开连接，原理和上面一样
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;
//如果prev==null 表示该链表只有一个元素
if (prev == null)
first = null;
else
prev.next = null;
//大小减1
size--;
modCount++;
return element;
}
查询位置
1、indexOf()获得值在链表中的位置，没有的话返回-1，有的话则返回最前面的位置。
public int indexOf(Object o) {
int index = 0;
//判断是否等于null
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
2、lastIndexOf 从队尾开始获取值在链表中的位置，没有则返回-1，有则返回其最后面的位置
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
清空：clear
将链表置空，需要循环释放每个节点，并将size=0，first 和last 置空。代码如下
public void clear() {
//for循环，当x==last时，跳出循环
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
//释放x节点
x.item = null;
x.next = null;
x.prev = null;
//进行下一轮循环，知道x==last是，x.next == null成立，跳出循环
x = next;
}
//将first和last置空
first = last = null;
//大小=0
size = 0;
modCount++;
}
总结
以上就是LinkedList最常用也是最基本的方法，其他的方法基本都是基于上面的方法增加了一些逻辑处理。
因为LinkedList是一个双向链表，所以它的增加和删除会比较快速，只需要修改相邻节点的指向就行了。
