Java中的LinkedList是一种实现了List接口的双向链表数据结构。链表是由一系列节点（Node）组成的，每个节点包含了指向上一个节点的指针prev,数据item和指向下一个节点next的指针。
- 实现了
Deque接口，可以在两端进行操作(插入、删除)。并且由于LinkedList内部是基于链表实现的，所以插入、删除数据时只需要改变链表指针的指向，时间复杂度为O(1)，而不需要进行数组的移动，所以它非常适合于频繁的插入、删除操作。但是LinkedList的缺点就是随机访问元素的速度较慢，因为需要从头开始遍历链表，时间复杂度为O(n)。 - 实现了
Cloneable接口，支持克隆功能 - 继承
Iterable接口，可以使用for-each迭代 - 实现了
List接口，支持增删改查的功能
源码分析（JDK1.8）
成员变量属性
/**
* 链表节点个数
*/
transient int size = 0;
/**
* 永远指向第一个节点
*/
transient Node<E> first;
/**
* 永远指向最末尾的节点
*/
transient Node<E> last;
/**
* 静态内部类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;
}
}
构造方法
LinkedList 有两个构造函数，空参构造方法，指定集合元素列表的构造方法
- 空参构造
/**
* 构造一个空列表
*/
public LinkedList() {
}
- 指定集合元素列表的构造方法
/**
* 按照集合迭代器返回的顺序，构造一个包含指定集合的元素的列表
*/
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
/**
* 将指定集合中的所有元素从此列表中的指定位置开始插入。将当前位于该位置的元素（如果有）
* 和任何后续元素向右移动（增加它们的索引）。新元素将按照指定集合的迭代器返回的顺序出现
* 在列表中。
*/
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index); //校验index是否有效,是否超出链表的实际长度
Object[] a = c.toArray(); //将集合转换成Object[] 数组
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
// 如果索引值与链表的长度一致.那么将此指定集合中的所有元素放在链表的末尾
if (index == size) {
succ = null;
pred = last;
} else {
// 如果不一致,就需要将指定集合中的所有元素从此列表中的指定位置开始插入
succ = node(index); //从链表中获取当前index位置的节点Node
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;
}
add(), 插入节点方法
ArrayList 的add方法有两个，末尾添加和指定位置添加
- 末尾添加
直接将新增节点添加在链表的最末尾处,然后指定新增节点的上一个节点prev为链表中的last节点,下一个节点next置为null
/**
* 将指定的元素追加到此列表的末尾
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 将e链接为最后一个元素.
*/
void linkLast(E e) {
final Node<E> l = last; //先获取链表最后一个节点
//将l节点设置为e元素节点上一个节点,因为是末尾添加,所以e元素的下一个节点next为null
final Node<E> newNode = new Node<>(l, e, null);
last = newNode; //先标记新增加的e元素节点为链表最末尾节点
if (l == null)
//如果l节点为null,说明当前链表没有任何节点,将新增的e元素节点设置为链表头节点
first = newNode;
else
//当前链表有其他节点,将l节点的next下一个节点指定为新增的e元素节点
l.next = newNode;
size++; //更新链表长度+1
modCount++; //记录链表数据结构的变化次数
}
- 指定位置添加
也叫插队添加，会打乱原本链表中节点的存储顺序。
public void add(int index, E element) {
//判断索引下标是否在链表长度范围内,超出范围则报IndexOutOfBoundsException
checkPositionIndex(index);
if (index == size)
//指定位置index正好等于链表的长度,那么就是尾部添加节点
linkLast(element);
else
//复杂一点,见下文源码
linkBefore(element, node(index));
}
/**
* 指定位置index之前添加节点
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev; //获取指定位置index节点的上一个节点pred
//将新增e元素节点的上一个节点指定为succ.prev,下一个节点next指向为succ
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode; //变更succ的上一个节点为新增e元素节点
if (pred == null)
//表明当前链表还没任何节点,标记新增e元素节点为链表的头节点
first = newNode;
else
//表明当前链表有节点,
pred.next = newNode,将succ.prev节点的下一个节点next更细为新增e元素节点
size++; //更新链表长度+1
modCount++; //记录链表数据结构的变化次数
}
remove(), 删除元素方法
LinkedList 的remove方法有两个，指定节点删除和指定位置删除；
- 指定节点删除
由于LinkedList 允许元素重复，所以指定元素删除方法可能存在删除多个。
public boolean remove(Object o) {
if (o == null) {
//指定的节点元素item为null,那么就从链表的frist节点开始遍历,将所有节点之间解绑
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;
}
/**
* 解绑
*/
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; //将前一个节点prve置为null
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null; //将下一个节点next置为null
}
x.item = null; //将节点元素item置为null
size--; //链表节点个数 -1
modCount++;
return element;
}
- 指定位置删除
最多只会删除一个元素，如果指定位置index超出数组结构长度，报错IndexOutOfBoundsException
public E remove(int index) {
checkElementIndex(index); //校验index的有效性
return unlink(node(index)); //先获取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; //将前一个节点prve置为null
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null; //将下一个节点next置为null
}
x.item = null; //将节点元素item置为null
size--; //链表节点个数 -1
modCount++;
return element;
}
set(), 修改节点元素方法
LinkedList 中的修改方法只有一个,通过index下标来精准修改, 修改元素节点的步骤,其实就是同一个位置的节点item的覆盖操作
,set方法只修改节点的item信息,prev和next信息不变
public E set(int index, E element) {
checkElementIndex(index); //校验index的有效性,IndexOutOfBoundsException
Node<E> x = node(index); //先获取index位置的节点
E oldVal = x.item;
x.item = element; //重新赋值
return oldVal;
}
get(), 取元素方法
LinkedList 的get方法只有一个，只能通过索引下标index获取
public E get(int index) {
checkElementIndex(index); //校验index的有效性,IndexOutOfBoundsException
return node(index).item; //核心, 有算法
}
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) { //用index与链表长度size的一半比较,右移>>位运算
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next; //从first开始,从前往后一个个遍历直到到达index所在位置
return x;
} else {
Node<E> x = last; //从last开始,从后向前一个个遍历直到到达index所在位置
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
