1.基本原理
底层是一个双向链表来维护数据,在JDK1.7之前是一个双向循环链表
2.优缺点
1.优点
插入删除性能好,容量没有限制
可以用作内存队列或栈
2.缺点
随机访问性能差
3.源码分析
1.add()方法
public boolean add(E e) {
linkLast(e);
return true;
}
调用了linkLast方法,然后返回true
linkLast方法如下:
首先让l指向last的位置,然后创建一个Node对象newNode,prev指针指向last,next指针指向null,元素为e,然后将last指向newNode节点,进入if判断,如果l为null说明是第一个元素,让first指向newNode,否则的话将newCode链接到l后面,最后进行size++
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;
}
}
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++;
}
小结:
1.使用临时指针l记录最后一个元素的位子
2.创建一个新的节点,让节点的prev指针指向l
3.再将last指针指向新的元素,如果是第一次添加,也会将first指针指向该节点
2.add(int index,E element)方法
该方法是在某个位置增加一个元素,首先判断index是否在0-size的范围,如果不在报出异常,然后根据index判断,如果index==size,调用linkLast方法向尾节点插入元素,否则调用linkBefore方法插入
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
首先通过node(int index)定位元素:
这里将size处以2来和index比较,如果index在左半边,从前开始寻找元素如果index在右半边,从后寻找元素(二分),确认了以后,执行linkBefore方法
Node<E> node(int index) {
// assert isElementIndex(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方法如下:
首先将之前node定位到的元素作为succ传入,pred指向它前一个节点,然后类似于linkLast方法插入元素
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 = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
3.removeLast方法
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
使用l记录尾节点的位置,然后调用unlinkLast方法:
首先通过l.prev找到前一个元素,记为prev,然后将l断开,将last指针指向prev节点,最后返回最后一个元素
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;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
4.removeFirst方法
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
使用f记录头节点的位置,然后调用unlinkFirst方法:
之后类似于上面的方法
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;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
5.remove(int index)方法
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
首先通过node方法定位节点,然后调用unlink方法:
通过next和prev两个指针断开x的前后指针,将next和prev重新相接,就可以从某个位置删除节点
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;
}