继承结构
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable{}
- LinkedList 实现了 List 接口,即能对它进行队列操作,提供了相关的添加、删除、修改、遍历等功能。
- LinkedList 实现了 Deque 接口,即能将LinkedList当作双端队列使用。
- LinkedList 实现了Cloneable接口,即覆盖了函数clone(),所以它能被克隆。
- LinkedList 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化进行传输。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
//transient :无法被Serializable序列化
//双向链表的节点个数
transient int size = 0;
//双向链表的头结点
transient Node<E> first;
//双向链表的尾节点
transient Node<E> last;
//初始化空集合
public LinkedList() {
}
//双向链表的节点个数
//构造一个包含指定集合的元素的列表,按照它们由集合的迭代器返回的顺序。
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
小结:LinkedList的属性比较少,
Size:双向链表节点个数,first头结点,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;
}
}
item代表当前节点,next代表当前节点的下一个节点,prev代表当前节点的上一个节点
小结:LinkedList是通过链表实现的,而链表是通过Node来实现的。
public boolean add(E e) {
//插入尾部元素
linkLast(e);
return true;
}
void linkLast(E e) {
//获取最后一个节点给赋给l
final Node<E> l = last;
//创建一个新节点,当前节点的前节点是l,当前节点的后节点是null
final Node<E> newNode = new Node<>(l, e, null);
//把新节点赋给最后一个节点
last = newNode;
if (l == null)
如果l节点为空,代表新节点赋给首节点
first = newNode;
else
//否则,当前节点的下一个节点为新newNode节点
l.next = newNode;
size++;
modCount++;
}
小结:
- 获取链表的最后一个节点。
- 创建一个新节点,把新节点赋给最后一个节点。
- 如果获取的最后一个节点为空,表示链表为空,则把新节点赋给首节点,否则,把新节点赋给
//在指定位置,插入元素
public void add(int index, E element) {
//检查索引位置
checkPositionIndex(index);
//如果索引位置和数组大小相同,直接在尾部插入该元素
if (index == size)
linkLast(element);
else
//否则在索引为index的前面插入元素
linkBefore(element, node(index));
}
//检查是否下标越界
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
void linkBefore(E e, Node<E> succ) {
// 获取当前节点的前节点
final Node<E> pred = succ.prev;
//创建新节点,记录当前节点的前为succ的前节点,后节点为succ节点
final Node<E> newNode = new Node<>(pred, e, succ);
//构建链表,当前节点的前节点为新节点
succ.prev = newNode;
//如果前节点为空,代表直接从0索引插入,则直接插入到第一个节点
if (pred == null)
first = newNode;
else
//否则插入到当前节点的前节点后面
pred.next = newNode;
//数量+1
size++;
//修改次数+1
modCount++;
}
小结:
- 获取当前节点前节点
- 创建需要插入元素的新节点
- 构建链表,获取当前节点前节点为新创建的节点
- 如果前节点为空,代表插入位置为0,所以直接赋值给链表首节点,否则插入到当前节点的前节点后面
public E remove() {
return removeFirst();
}
调用removeFirst删除链表第一个元素。
public E removeFirst() {
//取出第一个节点
final Node<E> f = first;
//检查第一个节点
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
private E unlinkFirst(Node<E> f) {
//拿到当前节点(第一个节点)
final E element = f.item;
//拿到当前节点的下一个节点
final Node<E> next = f.next;
//删除当前元素
f.item = null;
//删除当前元素的下标识,帮助gc内存回收
f.next = null; // help GC
//当前元素的下一个元素赋值给链表首元素
first = next;
//如果当前元素的下一个元素(第一个元素)为空,则最后的元素设置为空
if (next == null)
last = null;
else
//否则,把第一个元素的前标识设置为空,因为是首元素了
next.prev = null;
//数量-1
size--;
//修改次数+1
modCount++;
//返回删除的对象
return element;
}
删除元素小结:
- 默认拿到链表第一个元素,如果第一个元素为空抛出异常,否则,把第一个元素置为空,并且把当前元素下标识(记录后面一个元素的)置为空,帮助gc回收,然后把下一个元素赋值给链表首元素,最后第一个元素为空,则链表最后元素置为空,否则第一个元素的前标识置为空,记录数量和修改次数,返删除回对象。
public E removeLast() {
//拿到链表最后一个元素
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
private E unlinkLast(Node<E> l) {
//最后一个元素
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;
}
小结:
删除最后一个元素和删除首元素逻辑相似,唯一区别在于首元素的前标识位为空,尾部元素的后标识位为空。
public boolean remove(Object o) {
//当前移除元素为空
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;
}
E unlink(Node<E> x) {
//当前需要删除的元素
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;
}
//当前元素清空,gc回收
x.item = null;
size--;
modCount++;
return element;
}
小结:通过遍历元素找到元素进行删除,如果存在重复的值,则是默认是第一次找到的值进行删除。
public E set(int index, E element) {
//检查索引
checkElementIndex(index);
//找到节点
Node<E> x = node(index);
//临时存储老元素
E oldVal = x.item;
//替换 前后标识位无需变动
x.item = element;
return oldVal;
}
Node<E> node(int index) {
//数组元素大小右移1位就是等于一半 8>>2===4
//如果传入的索引小于大小的一般,左边查询
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;
}
}
小结:通过索引,从数组中间分一半查找,找到元素替换item值,其余前后标识位无需改动
public E get(int index) {
//检查索引
checkElementIndex(index);
//通过分一半查询获得数据,在元素过多的情况下,就算中间分一半去遍历,速度还是会慢
return node(index).item;
}
//集合头部加元素
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//集合尾部加元素
public boolean offerLast(E e) {
addLast(e);
return true;
}
//获取头部元素
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//获取尾部元素
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
//删除头部元素并获取
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//删除尾部元素并获取
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
//增加头部元素无返回值
public void push(E e) {
addFirst(e);
}
//删除头部元素并返回
public E pop() {
return removeFirst();
}
//调用remove方法,删除元素
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//删除最后一个元素 ,方法和上述一致
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
小结:以上方法都是调用类中写好的基础方法,用法都大同小异,知道用就行了。
ArrayList 和 LinkedList 的区别
- 二者都未实现线程锁,线程是不安全的,但是效率比 Vector 的高,Vector是线程安全的
- ArrayList 底层是以 数组 的形式保存数据,随机访问集合中的元素比LinkedList 快,因为ArrayList可根据指标直接获取,而LinkedList 需要至少分一半遍历查找。
- LinkedList 内部以 链表 的形式保存集合里面数据,它随机访问集合中的元素性能比较慢,但是新增和删除时速度比 ArrayList 快,原因是 ArrayList 要移动数据(也就是重新移位,底层重新复制数组),LinkedList只需要从插入的位置,打断增加,设置前后标识位即可。