LinkedList实现原理
LinkedList
LinkedList都是List下面的集合子类,LinkedList中和ArrayList在实现上有很大的区别,ArrayList是维护了一个Object的数组,而LinkedList在实现上维护了一个头指针节点对象Node first 和一个尾部指针节点对象Node last,而Node对象是LinkedList的静态内部类,为什么要是静态内部类?因为防止内存泄露,因为如果是普通的内部类,那么就会被其他对象锁实例化,就会出现内存泄露;
在上一篇笔记中,提到了ArrayList和LinkedList的比较,其实在很多场景下,ArrayList用的比较多,而LinkedList使用的场景比较少,因为LinkedList和ArrayList在添加的操作中,数据量没有达到一定的级别,性能是没有ArrayList好的,都说LinkedList是使用在写多读上的场景下,但是在数据量没有达一定的情况下,还是ArrayList性能较好;ArrayList 添加大批量数据的时候,耗时主要在数据的动态扩容进行数组复制的时候比较消耗性能,而LinkedList是每一个添加元素的时候都会创建一个Node节点对象,相当于就是说使用LinkedList的时候,要创建很多Node节点,而这些节点不像普通数组那样会存放在一块连续的内存空间中,LinkedList创建的Node对象在内存中各个区域中,通过前后指针进行迭代访问。
LinkedList源码分析
LinkedList本身也是List的子类,实现了List接口,具有List中的末尾添加元素、按位置添加元素、删除元素、迭代元素,而LinkedList还提供了从指定位置进行迭代的功能。
我们都知道ArrayList是通过Object数组来存储元素的,而LinkedList是通过Node来存储元素的,我的理解是这些Node都分配在不连续的空间上面,就是散落在内存块Cell中,当我们要用的时候通过游标来获取,我的理解如下:
LinkedList的继承关系
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
继承了AbstractSequentialList,本身和AbstractList没有什么区别,但是AbstractSequentialList完善了AbstractList中没有的功能,ArrayList继承之AbstractList,而AbstractSequentialList是AbstractList的子类,所以AbstractSequentialList就是对AbstractLIst中没有的功能进行完善。
其中的Cloneable和Serializable和ArrayList一样,都是标记接口,作用是标记可以复制克隆和序列化。
Deque:实现了Collection中的大家庭接口Queue队列接口。说明了它具有双端队列的功能(LinkedLIst和ArrayList的最大区别就是LinkedList实现了Deque接口,使的LinkedList具有了双端队列的功能)
基本属性
我这边提一下transient的作用,简单点说就是这个关键字就是序列化的作用域,加了这个关键字,那么被修饰的属性就不会被序列化了。为什么呢?因为我们的size是根据我们的集合大小而动态变化的,我们如果序列化出来过后,或者clone出来过后都是初始为0,我们不可能我们对集合序列化过后得到的是0,而且这样就节省空间,所以加了这个关键字就不会被序列化出来了。
//当前集合有多少个元素,泛指集合大小
transient int size = 0;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
//集合中的第一个元素
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
//集合中最后一个元素
transient Node<E> last;
//静态内部类,为了防止内存泄漏,设置为静态内部类
private static class Node<E> {
E item;//节点中的具体元素数据
Node<E> next;//后继指针游标
Node<E> prev;//前驱指针游标
//一般通过Node构造来创建Node节点对象
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
构造方法
//这个构造方法是默认将一个集合转换成一个LinkedList集合,
//完成过后,原有的集合对象就转成了LinkedList对象了
public LinkedList(Collection<? extends E> c) {
this();//调用默认的构造,现在默认的构造是一个空壳方法
//将集合全部添加到LinkedList中
addAll(c);
}
addAll方法
public boolean addAll(Collection<? extends E> c) {
//这里会把当前的size传入,如果是通过构造方法进入的,
//那么这个size是为0、
//如果是先创建了一个LinkedList过后,并且已经添加了元素过后,
//再来调用这个addall,
//那么这个size就不是空的,这个size就等于LinkedLIst的集合大小
return addAll(size, c);
}
//真正的添加集合到LinkedList的核心方法
public boolean addAll(int index, Collection<? extends E> c) {
//这里检查下标是否越界的方法
//判断的核心就是当前index是否是大于等于0并且小于等于size的
//因为这个方法入口不仅仅是通过构造调用的,还可以通过外部的
//LinkedList对象进行调用,因为这个方法是public
checkPositionIndex(index);
//先将要添加到LinkedList的集合collection转成一个普通的Object数组
Object[] a = c.toArray();
//得到转换过后的数组长度
int numNew = a.length;
//如果数组是等于0的,那么要添加的集合是空的,就不用执行后面的方法
if (numNew == 0)
return false;
//什么Node节点的前驱pre和后继next
Node<E> pred, succ;
//如果index == size,那么就有两种可能
//1.通过构造方法进行调用,这个时候index和size都是0
//2.通过外部对象调用时,从尾部进行添加,也就是传入的index
//是通过LinkedList的对象.size()获取到的,就是添加到尾部
if (index == size) {
//这里如果是通过构造进来的,那么succ=last=first=null
//如果是通过外部调用的,那么就是last=pred,也就是说
//从尾部开始添加,尾部的最后一个元素为前驱
succ = null;
pred = last;
} else {
//否则的话,从集合的某一个位置进行添加的,先获取到这个位置的
//游标指针,找到过后把游标指针的前驱赋值给pred
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
//e=Node.item
@SuppressWarnings("unchecked") E e = (E) o;
//创建一个Node对象,设置前驱,元素,后驱=null
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
//如果pred为空,则证明是通过构造调用的,last=first=null
//新创建Node赋值给first,这里也只有第一次能进入,第二次
//循环就不会进到这里了
first = newNode;
else
//当前元素指向pred的后继
pred.next = newNode;
//将当前创建的node赋值给pred,作为下一个Node前驱
//这里很重要,这块要自己去意会设计者的思路
//比如方法是通过构造进来的:那么pred肯定是空的,
//所以第一个节点first也就是第一次循环创建的node,
//把当前创建的node作为Node的第一个元素node,而第二次循环开始
//每个节点的next为新创建的node,而上一个元素node作为下一个、
//元素pred,这块只有去意会,好好理解一番,从你是设计者的角度
//去思考为什么要这么做
pred = newNode;
}
if (succ == null) {
//如果succ为空,则有两种情况:、
//1.从构造调用进来,那么first=last=null,
//当执行完成过后,last就是pred
//第二种情况是从尾部添加的
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
//元素个数计算
size += numNew;
//操作数+1,记录集合的操作数
modCount++;
return true;
}
Node<E> node(int index) {
// assert isElementIndex(index);
// if (index < (size >> 1)) 这行代码就是代码设计者的高明之处
//说白了就是通过看你的index到底是在集合的前半部分还是后半部分
//简单来说设计者是这样考虑的:比如集合是20,你传入的index是3
//那么我就从开头开始寻找,如果你传入的是15,那么我就从后面开始寻找
//就是寻址快,能快速找到我们的Node节点
if (index < (size >> 1)) {//二分查找方法
//如果index小于size的一半,那么从first开始找
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;
}
}
Add
//添加元素,从尾部添加
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
//添加元素,判断是否是第一个元素,如果是LinkedList
//创建过后的第一次添加,这first就是当前创建的节点node
//否则设置下一个节点也就是last.next就是当前创建的节点对象newNode
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指定位置添加
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//指位添加方法核心逻辑 操作新节点,
//紧接修改原有节点的前驱属性,最后再修改前驱节点的后继属性
void linkBefore(E e, Node<E> succ) {
final Node<E> pred = succ.prev;//原位置节点的前驱pred
final Node<E> newNode = new Node<>(pred, e, succ);//创建新节点,设置新节点其前驱为原位置节点的前驱pred,其后继为原位置节点succ
succ.prev = newNode;//将新节点设置到原位置节点的前驱
if (pred == null)//前驱如果为空,空链表,则新节点设置为first
first = newNode;
else
pred.next = newNode;//将新节点设置到前驱节点的后继
size++;//修改当前list的size
modCount++;//记录该list对象被执行修改的次数。
}
final修饰,不希望在运行时对变量做重新赋值
LinkedList 在插入数据优于ArrayList ,主要是因为他只需要修改指针的指向即可,而不需要将整个数组的数据进行转移。而LinkedList 由于没有实现 RandomAccess,或者说不支持索引搜索的原因,他在查找元素这一操作,需要消耗比较多的时间进行操作(n/2)。
GET
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
从上面的获取元素get方法就可以看出来为什么LinkedList的读取效率不如ArrayList了,每一次LinkedList都要通过index去寻找Node,虽然已经做了优化处理,比如是从前还是从后去找,但是肯定是没有ArrayList直接通过下标获取元素来的快,所以|ArrayList实现了RandomAccess随机访问标记接口,而LinkedList是没有的。
SET
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
在指定位置替换原有的元素,太简单了,不做介绍了,就是原来位置=3的地方放入的是“abc”,而通过set(3,“ert”)成功过后,位置还是3,值变成了ert.
通过指定位置迭代
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next;
private int nextIndex;
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() {
return nextIndex < size;
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
迭代都差不多,都有一个共同特征就是检查异常,fast-fail快速失败
linkedlist提供了向前迭代和向后迭代,这是和ArrayList的主要区别之一。
删除元素
1.AbstractSequentialList的remove
public E remove(int index) {
checkElementIndex(index);
//node(index)找到index位置的元素
return unlink(node(index));
}
//remove(Object o)这个删除元素的方法的形参o是数据本身,而不是LinkedList集合中的元素(节点),所以需要先通过节点遍历的方式,找到o数据对应的元素,然后再调用unlink(Node x)方法将其删除
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) {
//x的数据域element
final E element = x.item;
//x的下一个结点
final Node<E> next = x.next;
//x的上一个结点
final Node<E> prev = x.prev;
//如果x的上一个结点是空结点的话,那么说明x是头结点
if (prev == null) {
first = next;
} else {
prev.next = next;//将x的前后节点相连 双向链表
x.prev = null;//x的属性置空
}
//如果x的下一个结点是空结点的话,那么说明x是尾结点
if (next == null) {
last = prev;
} else {
next.prev = prev;//将x的前后节点相连 双向链表
x.next = null;
}
x.item = null;//指向null 方便GC回收
size--;
modCount++;
return element;
}
2.Deque 中的Remove
//将first 节点的next 设置为新的头节点,然后将 f 清空。 removeLast 操作也类似。
private E unlinkFirst(Node<E> f) {
final E element = f.item;
//获取到头结点的下一个结点
final Node<E> next = f.next;
f.item = null;
f.next = null; // 方便 GC
//头指针指向的是头结点的下一个结点
first = next;
//如果next为空,说明这个链表只有一个结点
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
双端链表(队列Queue)
java中队列的实现就是LinkedList: 我们之所以说LinkedList 为双端链表,是因为他实现了Deque 接口;我们知道,队列是先进先出的,添加元素只能从队尾添加,删除元素只能从队头删除,Queue中的方法就体现了这种特性。 支持队列的一些操作,我们来看一下有哪些方法实现:
pop()是栈结构的实现类的方法,返回的是栈顶元素,并且将栈顶元素删除
poll()是队列的数据结构,获取对头元素并且删除队头元素
push()是栈结构的实现类的方法,把元素压入到栈中
peek()获取队头元素 ,但是不删除队列的头元素
offer()添加队尾元素
可以看到Deque 中提供的方法主要有上述的几个方法,接下来我们来看看在LinkedList 中是如何实现这些方法的。
1.队列的增
offer()添加队尾元素
public boolean offer(E e) {
return add(e);
}
具体的实现就是在尾部添加一个元素
2、队列的删
poll()是队列的数据结构,获取对头元素并且删除队头元素
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
具体的实现前面已经讲过,删除的是队列头部的元素
3.队列的查
peek()获取队头元素 ,但是不删除队列的头元素
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
4.栈的增
push()是栈结构的实现类的方法,把元素压入到栈中
push() 方法的底层实现,其实就是调用了 addFirst(Object o)
public void push(E e) {
addFirst(e);
}
5.栈的删
pop()是栈结构的实现类的方法,返回的是栈顶元素,并且将栈顶元素删除
public E pop() {
return removeFirst();
}
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}