本文深入解析了LinkedList的源码实现，包括数据结构、构造方法、增删查改操作及迭代输出等内容，帮助读者理解其内部机制。
LinkedList源码解读
linkedList源码解读主要包括以下几个方面
- 数据结构
- 域
- 构造方法
- 添加元素
- 删除元素
- 查询元素
- 修改元素
- 迭代输出
- 线程安全
数据结构
LinkedList采用的是链表的数据结构，在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;
}
}域
在JDK1.8 API中查看LinkedList的field时，发现只有一个modCount，而且还是从AbstractList中继承而来。但是在源码中发现几个有transient修饰的变量。
modCount
size
//指示LinkedList当中实际的Node数量
transient int size = 0;- first
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
//LinkedList的头结点
transient Node<E> first;- last
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
//LinkedList的尾结点
transient Node<E> last;构造方法
- LinkedList()
//穿件一个空链表
public LinkedList() {
}- LinkedList(Collections c)
//通过传递进来一个集合来构造一个链表，并调用addAll()方法将集合转换成链表
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}添加元素
添加元素方法主要分为以下几类，第一类是将元素添加在链表的头结点出
- addFirst(E e) 在链表的开始出添加元素
public void addFirst(E e) {
linkFirst(e);
}我们来看看linkedFirst(E e)这个方法，这个方法是很重要的，对于链表在首部添加元素如果理解了这一块，那么后面的就都很好理解了
/**
* Links e as first element.
*/
private void linkFirst(E e) {
//定义一个Node应用将使f引用first的地址
final Node<E> f = first;
//定义一个节点，当前节点存储的元素值为 e ,并指向f这个节点（也就是同时指向 f 和 first Node）
final Node<E> newNode = new Node<>(null, e, f);
//first Node 引用了newNode的地址，此时first节点存储值为e,指向的下一个节点为之前的头结点 f
first = newNode;
//如果 f 节点为空，表示当前链表是空的，因此first = null && last == null;
//则此时first Node 和 last Node是同一个节点，否则last Node 保持不变.
//但是我们的 f Node(之前的头结点)的prev必须指向 newNode(first Node)
if (f == null)
last = newNode;
else
f.prev = newNode;
//链表元素增加，同时修改的次数也随着增加
size++;
modCount++;
}- addLast(E e) 在链表的开始出添加元素
public void addLast(E e) {
linkLast(e);
}在链表尾部添加元素不同的是这里调用的是linkLast(E e)方法，我们来看看链表尾部的方法
/**
* Links e as last element.
*/
void linkLast(E e) {
//首先定义一个 l Node 变量引用last的地址
final Node<E> l = last;
//创建一个newNode，newNode的前节点指向 l Node(last 这个Node)，存储的值为 e
final Node<E> newNode = new Node<>(l, e, null);
//将newNode的地址引用赋值给last，则此时last的 prev 为 l Node.
last = newNode;
//如果 l == null(也就是说之前的 last == null,那表明这个链表是一个空链表)
//对于一个空链表，当添加一个元素时，first 和 last 都同时first就是 last,而 last 也就是 first因此将 newNode 的地址赋给 first
//否则 l(这个之前的last Node因为添加元素后不再是last Node，因此要将l.next 引用新的last Node的地址)
if (l == null)
first = newNode;
else
l.next = newNode;
//增加链表中元素的数量，同时增加修改的次数
size++;
modCount++;
}- add(E e) 在元素末尾添加元素，添加成功则返回true
public boolean add(E e) {
linkLast(e);
return true;
}同样这个方法调用了linkedLast(E e)方法，add(E e)和addLast(E e)不同的是方法名不同，同时又返回值。其他的原理都是相同的。
- addAll(Collection c）将集合中的元素插入到链表的结尾
//注意如果这里的集和是空的，那么就会抛出一个 NullPointerException 异常
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}这个方法调用了下面我们需要讲解的方法addAll(int index,Collection c)
- addAll(int index, Collection c) 将集合中的元素从给定的具体的位置插入
public boolean addAll(int index, Collection<? extends E> c) {
//如果插入集合元素的位置是<0的或者是>size 的时候则抛出 IndexOutOfBoundsException 异常
checkPositionIndex(index);
//将集合转换成一个Object 对象的数组，如果集合的长度为零则返回false
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
//定义一个前继点 pred 和一个后继结点 succ；
//如果要集合添加的位置是链表的尾部(index == size),则pred = last,succ = null
//否则我们找到位于当前的index位置的节点，并将当前的节点的引用赋值给succ,而前一个节点的引用赋值给pred
//相当于将这个节点往后移，前一个节点的位置不变，将集合中的元素插入到这个位置
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
//第一步首先是将集合中的元素遍历一次则 new 一个 Node,如果我们当前的链表是一个空链表，那么首先初始化我们的 first Node,
//如果我们的链表不是空链表，那么只需要负责初始化pred Node 的下一个 节点的地址引用
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;
}
//当集合中所有的元素添加完毕以后，需要更新之前index处的Node的prev
//分两种情况讨论：如果我们是从尾节点开始插入元素，那么我们集合中最后一个插入的元素就是last
//否则我们的需要进行更新集合中最后一个插入的Node的next地址引用和之前index处Node的prev地址引用
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
//链表中的元素个数增加numNew个,但是链表的修改次数增加一次
size += numNew;
modCount++;
return true;
}- add(int index, E element) 在指定的位置插入一个元素
public void add(int index, E element) {
//如果插入集合元素的位置是<0的或者是>size 的时候则抛出 IndexOutOfBoundsException 异常
checkPositionIndex(index);
//如果插入的位置是从链表末尾插入，则调用linkLast(E e)
//否则调用linkBefore(E element,Node<E> e)方法
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}这里分两种情况讨论，从链表末尾插入元素和从链表中间插入元素
void linkBefore(E e, Node<E> succ) {
//首先我们找到要插入位置Node的前继节点
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++;
}- offer(E e) 在链表的末尾添加元素
//调用 add 方法将元素添加到链表的末尾
public boolean offer(E e) {
return add(e);
}- offerLast(E e) 在链表的尾部添加元素，插入成功返回true
public boolean offerLast(E e) {
addLast(e);
return true;
}其中offer(E e)和offerLast(E e)之间的不同之处在于
- offerFirst(E e) 在链表的头部添加元素，插入成功则返回true
//调用addFirst(E e)方法将元素添加在链表的头部
public boolean offerFirst(E e) {
addFirst(e);
return true;
}- push(E e) 在链表的头部添加元素
public void push(E e) {
addFirst(e);
}删除元素
- removeFirst()将链表中第一个节点移除，并返回头结点存储的值
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
} 我们这里调用了unlinkFirst(Node f)方法来移除当前链表的头结点
private E unlinkFirst(Node<E> f) {
//首先我们将头结点的存储的值保存下来
final E element = f.item;
//将头结点指向的下一个节点引用赋值给 next 这个 Node 变脸
//将头结点的item和next 置为空，JVM进行垃圾回收
f.item = null;
f.next = null; // help GC
//将头结点指向下一节点，如果下一个next这个节点引用一个空节点，
//那么表示我们这个链表只有一个元素，那么 last 也应该为 null，
//否则我们应该更新next这个节点的prev地址引用
first = next;
if (next == null)
last = null;
else
//链表中的元素减少一，增加链表操作的次数
size--;
modCount++;
//返回之前头结点存储的值
return element;
}- removeLast() 删除链表中为节点，并返回尾节点的值
public E removeLast() {
final Node<E> l = last;
//如果尾节点为空表明链表为null，则抛出 NoSuchElementException 异常
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}这里调用了unlinkLast(Node l)方法来删除尾节点，那么我们来看看这个方法
private E unlinkLast(Node<E> l) {
//保存尾节点的值
final E element = l.item;
//将尾节点的item和prev置为null，让JVM回收
l.item = null;
l.prev = null; // help GC
//更新last引用让last指向prev
last = prev;
//如果前一个节点为空，那么表明这个链表是一个只有一个节点的链表，因此在删除最后一个节点时相当于删除了头结点
//如果尾节点的头一个节点不为空，那么我们就应该更新前一个节点的引用后继节点为空
if (prev == null)
first = null;
else
prev.next = null;
//减少链表中的元素，但是增加链表操作的次数
size--;
modCount++;
//返回方法
return element;
}- remove(Object o) 删除链表中第一次出现对象o的节点
如果删除给定的对象，那么第一部是要找到存储该对象的值的节点，第二步是被删除节点的前继节点和后继节点的引用。如果链表中不存在要删除的元素，则返回false，如果存在则删除成功返回true
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;
}这里调用了unLink(Node x)这个方法,用来删除当前的节点
E unlink(Node<E> x) {
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
//如果要删除的节点时头结点，那么我们就将 first 指向 next
//否则我们就将当前节点 x 的 prev.next 指向 x 的 next ,同时将x.prev置为空
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
//如果要删除的节点是尾节点，那么我们就将 last 指向 prev
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是否>0且<=size
checkElementIndex(index);
//放回对应index的节点然后将其删除并更新
return unlink(node(index));
}- poll() 移除链表的头结点并返回头结点的元素
public E poll() {
final Node<E> f = first;
//如果头结点为空则返回null，如果调用unlinkFirst返回链表
return (f == null) ? null : unlinkFirst(f);
}- remove() 移除头结点并返回头结点的元素
public E remove() {
return removeFirst();
}- pollFirst() 移除头结点的元素
public E pollFirst() {
final Node<E> f = first;
//如果头节点为空则返回null，否则调用unlinkFirst(E f)移除头结点
return (f == null) ? null : unlinkFirst(f);
}- pollLast() 移除尾节点并返回尾节点的值
public E pollLast() {
final Node<E> l = last;
//如果尾节点为空则返回null，否则调用unlinkLast(E f)移除头结点
return (l == null) ? null : unlinkLast(l);
}- pop() 移除头结点并返回头结点淳出的值
public E pop() {
//调用removeFirst()方法将移除头结点并返回头结点淳出的值
return removeFirst();
}- removeFirstOccurrence(Object o) 移除链表中第一个与Object o相等的节点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}- removeLastOccurrence(Object 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;
}- clear()删除链表中所有的元素
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}查找元素
- getFirst()返回头结点存储的元素
如果链表为空则抛出 NoSuchElementException 异常
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}- getLast() 返回尾节点存储的元素
如果链表为空则抛出 NoSuchElementException 异常
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}- get(int index) 返回对应位置节点存储的值
首先调用node(int index)方法找到对应位置节点，然后返回节点存储的值
public E get(int index) {
//先检查索引是否有效，然后调用node()方法
checkElementIndex(index);
return node(index).item;
}- indexOf(Object o)
从链表的头从前往后找到第一次出现对应Object 对象所在的位置并返回索引；如果对应的元素不存在，那么则返回-1
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}- lastIndexOf(Object o)
从链表的尾从后往前找到第一次出现对应Object 对象所在的位置并返回索引；如果对应的元素不存在，那么则返回-1
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}- peek() 返回头节点存储的值
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}- element() 返回头结点存储的值
public E element() {
return getFirst();
}修改元素
- 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;
}迭代器输出
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();
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
