继承关系
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
实现了Deque的接口.(与其他子类相比)
参数列表 及构造函数
- size
- Node first
- Node last
- int modCount = 0; 没有什么特别的地方 就是链表的长度,头节点和尾节点.modCount用来记录修改表的次数.当你在迭代的时候会判断这个值.所以在迭代的时候不能进行一些增删改的操作.不然就会报错.
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
构造函数就只有为空,后者传入集合两种.当然如果传入一个集合为空会报空指针异常.(因为addAll()方法)
节点
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;
}
}
这是里面的内部静态类.有三个参数.值,前置和后置节点.能够看出这是一个双端队列.
常用API
增
add方法有两种:1是插入到尾部实际使用的是addLast(),2是插入到自己想要的位置.这里先展示如何将新的节点添加到头或者尾.
private void linkFirst(E e) {
//找到头节点
final Node<E> f = first;
//构造新的头节点
final Node<E> newNode = new Node<>(null, e, f);
//替换头节点
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
这是添加到第一个节点,
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
思想和linkFirst类似. 还有一个就是addall()方法.调用的是addAll(size, c)方法. 然后是稍微复杂的插入到指定位置. 先来看这个node(index)方法.用二分提高效率,都是我们以后可以模仿的写法.
Node<E> node(int index) {
//使用二分来提高查找的效率
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
重点其实是里面的linkBefore(element, node(index));
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
//找到需要插入位置的当前节点的前一个节点
// 1-2-3-4-5-6,你需要在把一个节点插入到4后面.肯定需要找4和5两个节点的.5 == succ. 4 == pred
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
//5-的前一个节点就是你插入的节点了.
succ.prev = newNode;
if (pred == null)
//当你需要插入到1之前的时候pred就会为空.
first = newNode;
else
//4的后一个节点为你需要插入的节点.
pred.next = newNode;
size++;
modCount++;
}
public boolean addAll(int index, Collection<? extends E> c) {
//检查索引( index >= 0 && index <= size;)这个进行判断是否越界.
checkPositionIndex(index);
//转为数组(基本这种情况都需要转为数组.高效简单推荐使用)
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
//如果正好是从节点最后添加.
//就是1-2-3-4-5-6,插入到6后面.所以他的pred为当前的last节点
succ = null;
pred = last;
} else {
//1-2-3-4-5-6 插入位置为6之前.
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)
//从头进行插入
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
//插入完成.需要把之前的节点接回去
if (succ == null) {
//这里代表是从最后插入,就没有后续节点需要插入了.
last = pred;
} else {
//典型的插入方法
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
删除
分为两种,1根据索引删除,2根据值删除 下面先是根据索引删除.重要的里面的 unlink(node(index))方法.
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;
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;
}
这里是找到要删除的节点,并且找到要删除节点的前一个节点和后一个节点.然后使前一个节点直接指向后一个节点.1-2-3-4-5-6,要删除4,找到3和5,使3-5.中间的判断是会出现删除1,或删除6.他们的前一个节点或者后一个节点会出现为空的可能.为了更快回收.将要删除的节点的内容置为null.
还有是根据值进行删除
//从头开始遍历.
public boolean remove(Object o) {
//应为可以存放null.不适用equls而是 ==
if (o == 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;
}
其他的查找和修改并不复杂.没什么特别的地方.
接下来是关于Deque的使用.
作为双端队列,既可以当作队列(FIFO)也可以当作栈(FILO)来使用.因为数据结构使用的是链表.插入的复杂度为O(1).非常的快.因为queue的实现中会有大小限制的出现(比如底层使用数组).所以add和offer在队列满的时候会出现不用的表现形式.linkedList并没有限制代下.所以一些实现看起来就会没有什么区别.另外这里的拷贝都是深拷贝.
