LinkedList使用链表存储数据，每个数据被封装进Node里面，可以存储null。由于使用链表存储数据，所以不能随机获取元素，需要遍历链表才能获取数据。插入或者删除节点比较简单，不需要数据的移动，但是定位到目标节点也需要遍历链表。
-
LinkedList的继承关系
可以看到LinkedList不仅实现了List接口，也实现了Deque接口。因此LinkedList不仅可以当做线性表来使用，也可以当做队列来使用，也可以当做栈来使用。
LinkedList.PNG
-
Node节点
从Node节点可以看出这个链表是双向的
private static class Node {
E item;
Node next;
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
-
重要参数
//链表的长度
transient int size = 0;
//链表的头结点
transient Node first;
//链表的尾节点
transient Node last;
-
构造函数
LinkedList由于使用链表实现，所以没有长度的限制。
//普通的构造函数
public LinkedList() {
}
//初始化链表为集合c
public LinkedList(Collection c) {
this();
addAll(c);
}
public boolean addAll(Collection c) {
//在构造函数中size的值为0
return addAll(size, c);
}
//添加集合c的元素
public boolean addAll(int index, Collection c) {
//检查index的值是否在
checkPositionIndex(index);
//获取集合的array
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
//辅助将集合加到链表上
Node pred, succ;
//这种是从链表的末尾开始添加集合集合节点
if (index == size) {
succ = null;
pred = last;
} else {
//从链表的第index个节点开始添加集合节点
//获取链表的第index个节点
succ = node(index);
pred = succ.prev;
}
//不断遍历集合的数组将节点添加到链表上
for (Object o : a) {
E e = (E) o;
Node newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
//succ为null，就是从链表的末尾开始添加的集合节点
//只需要last引用就可以了
if (succ == null) {
last = pred;
} else {
//succ不为null，则是从链表的第index节点开始添加集合的元素
//将集合末尾节点的next指向succ，succ就是原链表index+1节点
pred.next = succ;
//因为是双向链表，succ.pre也要更新
succ.prev = pred;
}
//更新节点数量
size += numNew;
modCount++;
return true;
}
注意其中的node(int)方法，这个方法用来获取链表的第index个节点。当index小于size/2，从前向后查找；当index>size/2，从后往前查找。这样可以节省不必要的时间。
//获取链表中第index节点的函数
Node node(int index) {
// assert isElementIndex(index);
//当index小于size/2时，从前向后找
//当index大于size/2时，从后向前找
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
-
常用的函数
add(E e)方法，在链表的末尾添加节点
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node l = last;
//新建节点，前驱为l，也就是last
final Node newNode = new Node<>(l, e, null);
//更新last
last = newNode;
// l为null，就是链表为空，更新first节点
//否则将节点添加到last的next
if (l == null)
first = newNode;
else
l.next = newNode;
//增加size
size++;
modCount++;
}
remove(Object o) 移除第一个o节点，如果链表中有多个o节点，则只会移除第一个。
public boolean remove(Object o) {
//分为null和非null，为非null时，使用equals进行比较
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
//移除x节点
E unlink(Node x) {
final E element = x.item;
//x节点的next
final Node next = x.next;
//x节点的prev
final Node prev = x.prev;
//prev为null，则x节点为头结点，更新first为next
if (prev == null) {
first = next;
} else {
//prev不为null，则将prev.next置x的next
prev.next = next;
x.prev = null;
}
//next为null，则x节点为last
if (next == null) {
//更新last节点
last = prev;
} else {
//next不为null，需要将next.prev置x的prev
next.prev = prev;
x.next = null;
}
//帮助GC
x.item = null;
//减小元素数量
size--;
modCount++;
return element;
}
contains(Object o)函数，检查链表中是否存在对象o
public boolean contains(Object o) {
return indexOf(o) != -1;
}
//查找对象o的下标
//分为null和非null
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
get(int index)获取下标为index的元素
public E get(int index) {
//检查index下标是否符合
checkElementIndex(index);
//node(int index)函数已经分析过
return node(index).item;
}
set(int index, E element) 替换index处的元素
public E set(int index, E element) {
checkElementIndex(index);
Node x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
add(int index, E element) 在index处插入元素
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
//在链表的末尾添加元素
linkLast(element);
else
//在链表的中间位置插入元素
linkBefore(element, node(index));
}
//在链表末尾添加元素
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
//last为null，则新节点为头结点
if (l == null)
first = newNode;
else
//在last的next添加节点
l.next = newNode;
size++;
modCount++;
}
//在succ之前插入节点e
void linkBefore(E e, Node succ) {
//获取succ(index处的节点)的前驱
final Node pred = succ.prev;
final Node newNode = new Node<>(pred, e, succ);
//将succ的前驱节点置为新的节点
succ.prev = newNode;
//index处节点的前驱为null，index处的节点为原头结点，则将新的节点置为first
if (pred == null)
first = newNode;
else
//否则将index处节点的前驱设置为新的节点
pred.next = newNode;
size++;
modCount++;
}
remove(int index) 移除index处的节点
public E remove(int index) {
checkElementIndex(index);
//使用node(int)获得第index个节点，再使用unlink移除节点
//这两个函数已经分析过
return unlink(node(index));
}
lastIndexOf(Object o) 从后往前找对象o
public int lastIndexOf(Object o) {
int index = size;
//分为null和非null
if (o == null) {
for (Node x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
clear() 清除所有节点
public void clear() {
for (Node x = first; x != null; ) {
Node next = x.next;
//全部置null
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
-
Queue接口的方法
peek() 这是实现Queue接口的方法。返回链表的第一个节点。此时链表可以看做队列。
public E peek() {
final Node f = first;
return (f == null) ? null : f.item;
}
offer(E e) 向链表(队列)的末尾添加节点
public boolean offer(E e) {
//调用add方法
return add(e);
}
poll() 移除链表的头结点
public E poll() {
final Node f = first;
//链表不为空时，使用unlinkFirst移除头结点
return (f == null) ? null : unlinkFirst(f);
}
//也可以使用unlink代替
private E unlinkFirst(Node f) {
// assert f == first && f != null;
final E element = f.item;
//获取头结点的后驱
final Node next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
//链表只有一个头结点，更新last为null
if (next == null)
last = null;
else
//否则，将头结点的后驱切点的前驱置null
next.prev = null;
size--;
modCount++;
return element;
}
pollLast() Deque中的方法，移除链表的末尾节点
public E pollLast() {
final Node l = last;
return (l == null) ? null : unlinkLast(l);
}
private E unlinkLast(Node l) {
final E element = l.item;
//获取尾节点的前驱
final Node prev = l.prev;
l.item = null;
l.prev = null; // help GC
//last置为last的前驱
last = prev;
//如果尾节点的前驱为null，则表示链表中只有一个节点
//则将first置null
if (prev == null)
first = null;
else
//否则，将prev(last)的后驱置null
prev.next = null;
size--;
modCount++;
return element;
}
pop() 移除链表的头节点，当链表为空时，会抛出异常。可以当做栈来使用。Deque中的方法
public E pop() {
//移除头结点
return removeFirst();
}
public E removeFirst() {
final Node f = first;
//链表为空，则抛出异常
if (f == null)
throw new NoSuchElementException();
//调用unlinkFIrst
return unlinkFirst(f);
}
push(E e) 加入到链表的头部。类似于栈，栈的push是向栈顶压入。
public void push(E e) {
addFirst(e);
}
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node f = first;
//设置新建节点的后驱节点为first
final Node newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
//头结点为null，则置last为新建节点
last = newNode;
else
//头结点不为null，则更新头结点的前驱为新建节点
f.prev = newNode;
size++;
modCount++;
}