目录
1. 简介
LinkedList是一个实现了List接口和Deque接口的双端链表。 LinkedList底层的链表结构使它支持高效的插入和删除操作,另外它实现了Deque接口,使得LinkedList类也具有队列的特性; LinkedList不是线程安全的,如果想使LinkedList变成线程安全的,可以调用静态类Collections类中的synchronizedList方法:
List list=Collections.synchronizedList(new LinkedList(...));
2. 内部结构
LinkedList类中的一个内部私有类Node
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。这个类有三个属性,分别是前驱节点,本节点的值,后继结点。
总结一下:
- 链表每个节点我们叫做 Node,Node 有 prev 属性,代表前一个节点的位置,next 属性,代表后一个节点的位置;
- first 是双向链表的头节点,它的前一个节点是 null。
- last 是双向链表的尾节点,它的后一个节点是 null;
- 当链表中没有数据时,first 和 last 是同一个节点,前后指向都是 null;
- 因为是个双向链表,只要机器内存足够强大,是没有大小限制的。
3. 源码分析
3.1 构造方法
- 空构造方法
public LinkedList() {
}
- 用已有的集合创建链表的构造方法
public LinkedList(Collection <? extends E > c) {
this();
addAll(c);
}
3.2 add方法
- add(E e) 方法:将元素添加到链表尾部
public boolean add(E e) {
linkLast(e); //从尾部添加节点
return true;
}
/**
* 链接使e作为最后一个元素。
*/
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++;
}
- add(int index, E e) 方法:在指定位置添加元素
public void add(int index, E element) {
checkPositionIndex(index); //检查索引是否处于[0-size]之间
if(index == size) //添加在链表尾部
linkLast(element);
else //添加在链表中间
linkBefore(element, node(index));
}
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++;
}
- addAll(Collection c ) 方法:将集合插入到链表尾部
public boolean addAll(Collection <? extends E > c) {
return addAll(size, c);
}
- addAll(int index, Collection c) 方法: 将集合从指定位置开始插入
public boolean addAll(int index, Collection <? extends E > c) {
//1:检查index范围是否在size之内
checkPositionIndex(index);
//2:toArray()方法把集合的数据存到对象数组中
Object[] a = c.toArray();
int numNew = a.length;
if(numNew == 0) return false;
//3:得到插入位置的前驱节点和后继节点
Node < E > pred, succ;
//如果插入位置为尾部,前驱节点为last,后继节点为null
if(index == size) {
succ = null;
pred = last;
}
//否则,调用node()方法得到后继节点,再得到前驱节点
else {
succ = node(index);
pred = succ.prev;
}
// 4:遍历数据将数据插入
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;
}
//如果插入位置在尾部,重置last节点
if(succ == null) {
last = pred;
}
//否则,将插入的链表与先前链表连接起来
else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
addAll方法通常包括下面四个步骤:
- 检查index范围是否在size之内
- toArray()方法把集合的数据存到对象数组中
- 得到插入位置的前驱和后继节点
- 遍历数据,将数据插入到指定位置
- addFirst(E e)方法: 将元素添加到链表头部
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node < E > f = first;
final Node < E > newNode = new Node < > (null, e, f); //新建节点,以头节点为后继节点
first = newNode;
//如果链表为空,last节点也指向该节点
if(f == null) last = newNode;
//否则,将头节点的前驱指针指向新节点,也就是指向前一个元素
else f.prev = newNode;
size++;
modCount++;
}
- addLast(E e) 方法: 将元素添加到链表尾部,与 add(E e) 方法一样
public void addLast(E e) {
linkLast(e);
}
3.3 get方法
- get(int index) 方法: 根据指定索引返回数据
public E get(int index) {
//检查index范围是否在size之内
checkElementIndex(index);
//调用Node(index)去找到index对应的node然后返回它的值
return node(index).item;
}
node(int index) 方法做了一个小优化,如果查询的下标小于集合数量的一半时,表示更偏向小的下标,于是就从前往后找,反之更偏向于大的下标,就从后往前找。
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;
}
}
- 获取头节点(index=0)数据方法
public E getFirst() {
final Node < E > f = first;
if(f == null) throw new NoSuchElementException();
return f.item;
}
public E element() {
return getFirst();
}
public E peek() {
final Node < E > f = first;
return(f == null) ? null : f.item;
}
public E peekFirst() {
final Node < E > f = first;
return(f == null) ? null : f.item;
}
区别: getFirst(),element(),peek(),peekFirst() 这四个获取头结点方法的区别在于对链表为空时的处理,是抛出异常还是返回null,其中getFirst() 和element() 方法将会在链表为空时,抛出异常。
- 获取尾节点(index=-1)数据方法
public E getLast() {
final Node < E > l = last;
if(l == null) throw new NoSuchElementException();
return l.item;
}
public E peekLast() {
final Node < E > l = last;
return(l == null) ? null : l.item;
}
两者区别: getLast() 方法在链表为空时,会抛出NoSuchElementException,而peekLast() 则不会,只是会返回 null。
3.4 remove方法
- remove() ,removeFirst(),pop(): 删除头节点
public E pop() {
return removeFirst();
}
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node < E > f = first;
if(f == null) throw new NoSuchElementException();
return unlinkFirst(f);
}
- removeLast(),pollLast(): 删除尾节点
public E removeLast() {
final Node < E > l = last;
if(l == null) throw new NoSuchElementException();
return unlinkLast(l);
}
public E pollLast() {
final Node < E > l = last;
return(l == null) ? null : unlinkLast(l);
}
区别: removeLast()在链表为空时将抛出NoSuchElementException,而pollLast()方法返回null。
- remove(Object o): 删除指定元素
public boolean remove(Object o) {
//如果删除对象为null
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;
}
当删除指定对象时,只需调用remove(Object o)即可,不过该方法一次只会删除一个匹配的对象,如果删除了匹配对象,返回true,否则false。
- unlink(Node 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; //得到前驱节点
//删除前驱指针
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;
}
- remove(int index):删除指定位置的元素
public E remove(int index) {
//检查index范围
checkElementIndex(index);
//将节点删除
return unlink(node(index));
}