基于jdk1.8的LinkedList的源码分析
前言：上篇文章我们已经分析了ArrayList的源码，了解到ArrayList的底层其实是数组结构，但是今天分析LinkedList的底层结构不太一样，它的底层是基于链表来实现的。本文我们还是会从构造方法、增加元素、删除元素、修改元素、查找元素以及它的遍历来进行解析。
一：基本的链表
在开始分析LinkedList的源码之前，我们先了解一下基本的链表结构，方便我们对源码有更好理解。链表一般分为单向链表和双向链表。
1.1：单向链表
单向链表的结构如上图所示：data指数据，next是下一个数据的具体指向，最后一个数据的具体指向为null。
优点：单向链表增加删除节点简单。
缺点：获取元素只能从头到尾遍历而且只能找到后面的元素，不能找到前面的元素。
1.2：双向链表
双向链表的结构如上图所示：data用来存储数据，next是下一个数据的指向，pre是上一个数据的指向，第一个数据的pre和最后一个数据的next指向的都为null。LinkedList的底层实现就是采用这种双向链表结构。
优点：可以找到前元素和后元素，可进可退。
缺点：增加删除节点复杂，需要多分配一个指针存储空间。
二：LinkedList的具体实现
2.1：构造函数
LinkedList list = new LinkedList();
LinkedList list1 = new LinkedList(new ArrayList());
2.2：成员变量
//实际存储的元素个数
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;
}
}
2.3：构造函数的具体实现
//空参构造
public LinkedList() {
}
//带参构造
public LinkedList(Collection<? extends E> c) {
//有参构造函数，其实是调用了无参构造函数
this();
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
//检查空指针异常
checkPositionIndex(index);
//转换成数组
Object[] a = c.toArray();
//记录下数组的长度
int numNew = a.length;
//入参为空
if (numNew == 0)
return false;
//定义两个节点，pred记录前置节点，succ记录后置节点
Node<E> pred, succ;
//1.1:下面是为了找到在什么地方插入元素
//如果index == size 说明是在当前集合的尾部插入数据，此时后节点为null，前节点是之前元素的后节点
if (index == size) {
succ = null;
pred = last;
} else {
//否则，找到当前下标指代的节点，要在该节点之前插入数据，所以succ等于该节点
succ = node(index);
//pred就等于succ前一位的节点
pred = succ.prev;
}
//1.2:下面是为了把元素插进去，并且前后节点建立联系
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
//新建一个节点对象，pred为前置节点，e为元素，null为后置节点
Node<E> newNode = new Node<>(pred, e, null);
//第一次进来前置节点是null，所以把新节点赋值给first
if (pred == null)
first = newNode;
else
//前置节点不为空时，把新节点赋值给前置节点的下一个节点
pred.next = newNode;
//令新节点等于前置节点，方便下一次循环得到下一个节点
pred = newNode;
}
//1.3:下面是一个链接的过程
//如果succ为null，说明是在集合的尾部插入的元素，所以让插入的最后一个元素赋值给last
if (succ == null) {
last = pred;
} else {
//如果succ不为null，说明不是在尾部插入的元素，这个时候pred是最后插入的元素，
//succ是拆开节点的位置，所以令succ等于pred的下一个节点，
//succ节点拆来之前的前置节点为succ.prev,所以令pred等于之前的前置节点
pred.next = succ;
succ.prev = pred;
}
//新插入numNew条数据，size增加相应的大小。
size += numNew;
modCount++;
return true;
}
private void checkPositionIndex(int index) {
//如果不符合抛出角标越界异常
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
//初次构建的时候index和size都为0
return index >= 0 && index <= size;
}
//根据index下标获取到相应的节点
//由于是双向链表，这个地方会去判断索引位置（size/2），前半段从头节点开始查找，后半段从尾节点开始查找
Node<E> node(int index) {
// assert isElementIndex(index);
//判断插入元素的位置是在前半段还是在后半段
if (index < (size >> 1)) { //size/2的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;
}
}
2.4：LinkedList之增加元素
增加元素的方法有七种，我们来逐一解析：
add(E)；
add(int index, E element)；
addAll(Collection<? extends E> c)；
addAll(int index, Collection<? extends E> c)；
addFirst(E e)；
addLast(E e)；
push(E e)；
2.4.1：add(E)源码解析
//默认直接在末尾添加元素
public boolean add(E e) {
linkLast(e);
return true;
}
//添加元素到尾部
void linkLast(E e) {
//存储原链表的尾部节点
final Node<E> l = last;
//创建一个新的节点，之前的尾部节点为前置节点，后置节点为null
final Node<E> newNode = new Node<>(l, e, null);
//重新赋值尾部节点
last = newNode;
//如果尾部节点为空
if (l == null)
//那么新增加的节点就是第一个节点
first = newNode;
else
//否则，新节点就是尾部节点的下一个节点
l.next = newNode;
//链表长度 +1
size++;
//修改次数 +1
modCount++;
}
2.4.2：add(int index, E element)源码解析
//在指定的下标中添加元素
public void add(int index, E element) {
//检查下标是否越界
checkPositionIndex(index);
//如果index=size，就在尾部添加元素
if (index == size)
linkLast(element);
else
//否则就是在前面添加元素，添加之前先找到该元素的位置
linkBefore(element, node(index));
}
//检查下标是否越界
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//在尾部添加元素
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++;
}
//根据下标找到指定的元素
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;
}
}
//在节点前添加元素
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++;
}
2.4.3：addAll(Collection<? extends E> c)源码分析
public boolean addAll(Collection<? extends E> c) {
//链表尾部添加元素,上面已经解析过了
return addAll(size, c);
}
2.4.4：addAll(int index, Collection<? extends E> c)源码解析
//根据下标插入元素，具体见上面分析
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
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;
}
2.4.5：addFirst(E e)的源码解析
//在起始节点添加元素
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
//记录首节点
final Node<E> f = first;
//新建节点，把前置节点置为null，后置节点就是之前的首节点
final Node<E> newNode = new Node<>(null, e, f);
//令新节点为首节点
first = newNode;
//首节点为null，那么就只有一个元素，这个元素也就是最后一个元素
if (f == null)
last = newNode;
else
//首节点不为null，那么新节点就是首节点的前置节点
f.prev = newNode;
size++;
modCount++;
}
2.4.6：addLast(E e)源码解析
//在尾部添加元素
public void addLast(E e) {
linkLast(e);
}
void linkLast(E e) {
//记录尾部节点
final Node<E> l = last;
//新建一个节点，前置节点是尾部节点，后置节点为null
final Node<E> newNode = new Node<>(l, e, null);
//新节点赋值给最后一个元素
last = newNode;
//尾部为null，只有一个元素，尾节点就是最后一个节点
if (l == null)
first = newNode;
else
//否则，新节点就是尾部节点的后置节点
l.next = newNode;
size++;
modCount++;
}
2.4.7：push(E e)源码解析
//添加首节点
public void push(E e) {
addFirst(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;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
2.5：LinkedList之删除元素
删除元素的常用方法有如下七种，我们来逐一解析：
E remove();
E remove(int index); //根据下标删除元素
boolean remove(Object o); //删除元素o
E removeFirst(); //删除头结点
E removeLast(); //删除尾结点
boolean removeFirstOccurrence(Object o); //删除此节点中第一次出现的o
boolean removeLastOccurrence(Object o); //删除此节点中最后一次出现的o
2.5.1：remove()源码解析
//删除首元素
public E remove() {
return removeFirst();
}
public E removeFirst() {
//记录首元素
final Node<E> f = first;
if (f == null)
//首元素为空抛出异常
throw new NoSuchElementException();
return unlinkFirst(f);
}
//
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
//记录首节点的元素
final E element = f.item;
//记录首节点的下一个节点
final Node<E> next = f.next;
//把首节点元素置为null
f.item = null;
//把首节点的下一个节点置为null
f.next = null; // help GC
//接着把下一个节点设置为首节点
first = next;
//如果下一个节点为空，说明只有一个元素，那么删掉后last就是null
if (next == null)
last = null;
else
//否则，下一个节点的前置节点就是null
next.prev = null;
//删掉一个节点，整体的size -1
size--;
modCount++;
//返回删除的元素
return element;
}
2.5.2： remove(int index)源码解析
//会根据下标删除元素
public E remove(int index) {
//检查下标越界
checkElementIndex(index);
return unlink(node(index));
}
//根据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;
}
}
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;
//如果该节点的前节点是null，说明是首节点，那么令下一个节点为首节点
if (prev == null) {
first = next;
} else {
//否则，令该节点的前节点的下一个节点为该节点的下一个节点
prev.next = next;
//并令该节点的前置节点为null
x.prev = null;
}
//如果后置节点为null，说明是最后一个节点，令最后节点为该节点的前一个节点
if (next == null) {
last = prev;
} else {
//否则，就令前下一个节点的前置节点等于当前节点的前置节点
next.prev = prev;
//并让该节点后置节点为null
x.next = null;
}
//置元素为null
x.item = null;
size--;
modCount++;
return element;
}
2.5.3：remove(Object o)源码解析：
//删除元素
public boolean remove(Object o) {
//如果删除的元素为null
if (o == null) {
//遍历链表所有的数据
for (Node<E> x = first; x != null; x = x.next) {
//如果元素值为null，删掉
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
//如果元素不为null
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;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
2.5.4：removeFirst()源码解析
//删除首节点
public E removeFirst() {
//记录首节点
final Node<E> f = first;
//首节点为null，抛错
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
//删除首节点，见上面分析
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;
}
2.5.5：removeLast()源码分析
//删除尾部节点
public E removeLast() {
//记录尾部节点
final Node<E> l = last;
//为空，抛错
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//删除尾部节点
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
//记录尾部节点的元素
final E element = l.item;
//记录尾部节点的前置节点
final Node<E> prev = l.prev;
//让元素为null
l.item = null;
//让前置节点为null
l.prev = null; // help GC
//令最后的节点为删除节点的前置节点
last = prev;
//如果前置节点为null，说明是首节点，那么令首节点为null
if (prev == null)
first = null;
else
//否则前置节点的下一个节点置为null
prev.next = null;
size--;
modCount++;
return element;
}
2.5.6：removeFirstOccurrence(Object o)源码解析
//删除此节点中第一次出现的o
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//具体解析见上文
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;
}
2.5.7：removeLastOccurrence(Object o)源码解析
//删除此节点中最后一次出现的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;
}
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;
}
2.6：LinkedList之修改元素
set(int index, E element)
源码解析：
public E set(int index, E element) {
//检查下标越界
checkElementIndex(index);
//找到该节点的位置
Node<E> x = node(index);
//记录旧节点的值
E oldVal = x.item;
//令旧等于新元素
x.item = element;
//返回旧元素
return oldVal;
}
2.7：LinkedList之获取元素
获取元素有如下三种方法，我们来逐一分析：
get(int index)；
getFirst()；
getLast()；
2.7.1：get(int index)源码解析
//根据下标获取元素值
public E get(int index) {
//检查下标越界
checkElementIndex(index);
return node(index).item;
}
//根据下标获取到具体的节点位置，上没有分析
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;
}
}
2.7.2：getFirst()源码分析
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
2.7.3：getLast()源码分析
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
2.8：LinkedList之遍历
list.listIterator()
2.8.1：list.listIterator()源码解析
public ListIterator<E> listIterator() {
return listIterator(0);
}
public ListIterator<E> listIterator(final int index) {
rangeCheckForAdd(index);
return new ListItr(index);
}
//在这里我们可以看见ListItr继承自Itr并且实现了ListIterator，在之前分析的ArrayList的文章里就提到过
//Itr这个内部类，其中的next()和hasNext()方法和之前的一样。
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public E previous() {
checkForComodification();
try {
int i = cursor - 1;
E previous = get(i);
lastRet = cursor = i;
return previous;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor-1;
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.set(lastRet, e);
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
AbstractList.this.add(i, e);
lastRet = -1;
cursor = i + 1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
三：总结
1：LinkedList插入数据和删除数据比较快，查询比较慢，因为需要遍历真个链表才可以找到该元素；
2：LinkedList父类继承了Iterable，遍历的时候使用iterator循环，效率更高；
3: LinkedList所有指定位置的操作都是从头开始遍历进行的；
4: LinkedList线程不安全，可以使用：List list = Collections.synchronizedList(new LinkedList(…))；
5: LinkedList允许null值；
至此，ArrayList的源码研究告一段落，欢迎大家一起讨论学习。
了解更多干货，欢迎关注我的微信公众号：爪哇论剑
476
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
