Java集合------LinkedList源码剖析

LinkedList简介

LinkedList是一个实现了List接口和Deque接口的双端链表，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。LinkedList不是线程安全的，只在单线程下适合使用。如果想使LinkedList变成线程安全的，可以使用如下方式：

List list=Collections.synchronizedList(new LinkedList(...));

继承关系

public class LinkedList<E>
extends AbstractSequentialList<E>

实现接口

implements List<E>, Deque<E>, Cloneable, java.io.Serializable

内部结构

LinkedList是基于双向循环链表设计的，结构如下图所示：



LinkedList内部是一个双向链表结构，有两个变量，first指向链表头部，last指向链表尾部。它的成员变量如下所示：

//容量
transient int size = 0;

/**
* 首节点
* Invariant: (first == null && last == null) ||
*            (first.prev == null && first.item != null)
*/
transient Node<E> first;

/**
* 尾节点
* Invariant: (first == null && last == null) ||
*            (last.next == null && last.item != null)
*/
transient Node<E> last;

下边是Node节点的定义，从源码可以看出Node是LinkedList的静态内部类

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;
}
}

构造方法

//默认构造方法
public LinkedList() {
}

//将一个指定集合添加到LinkedList中，先完成初始化，在调用添加操作，元素顺序由这个集合的迭代器返回顺序决定
//当集合为空时，报NullPointerException
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}

添加操作

LinkedList提供了很多添加操作，包括将元素添加到头部或者尾部，也可以将元素添加到指定索引位置，还可以添加添加整个集合；下边我们首先来分析add(E e)方法，该方法是将元素添加到链表尾部。源代码如下

//添加元素到链表尾部
public boolean add(E e) {
linkLast(e);
return true;
}

//将节点值为e的节点设置为链表的尾节点
void linkLast(E e) {
final Node<E> l = last;//得到尾节点
final Node<E> newNode = new Node<>(l, e, null);//构建一个prev值为l,节点值为e,next值为null的新节点newNode
last = newNode;//将newNode作为尾节点
if (l == null)//如果链表为空，新节点即是头结点也是尾节点
first = newNode;
else
l.next = newNode;//链表不为空，那么将新结点作为原链表尾部的后继节点
size++;长度加1
modCount++;
}

接下来我们在看看add(int index,E e)，该方法是将元素添加到指定位置，源代码如下

//将元素添加到指定位置
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) {
// assert succ != null;
final Node<E> pred = succ.prev;//获取前一个节点
final Node<E> newNode = new Node<>(pred, e, succ);//构建一个值为e的新节点，前驱指向perd，后继节点指向succ
succ.prev = newNode;//将succ的前驱节点指向新节点
if (pred == null)//如果前一个节点为null，新的节点就是首节点
first = newNode;
else
pred.next = newNode;//如果存在前节点，那么前节点的向后指向新节点
size++;
modCount++;
}

接下来我们在看看addAll方法，它有两个重载方法，一个是添加在链表尾部，另一个是在指定位置插入，源代码如下

//将集合插入到链表尾部，size是链表最后一个位置
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;//若元素为空，直接返回false

Node<E> pred, succ;//得到插入位置的前驱节点和后继节点
if (index == size) {//如果插入位置为尾部，前驱节点为last，后继节点为null
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;//如果前节点为null，则新加的节点为首节点
else
pred.next = newNode;//如果存在前节点，前节点会向后指向新加的节点
pred = newNode;//新加的节点成为前一个节点
}

if (succ == null) {
last = pred;
} else {
pred.next = succ;//如果不是从最后开始添加的，则最后添加的节点向后指向之前得到的后续第一个节点
succ.prev = pred;//当前，后续的第一个节点也应改为向前指向最后一个添加的节点
}

size += numNew;
modCount++;
return true;
}

查找操作

首先我们先看看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;
}
}

我们继续看看getFirst()、element()、peek()、peekFirst()，这四个方法都是获取头结点的数据，其中getFirst()、element()会判断如果当前链表为空，那么抛出异常。而peek()、peekFirst()当链表为空时，这两个方法返回null。源码如下

public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}

public E element() {
return getFirst();
}

public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}

public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}

既然有获取头结点的数据，那肯定也有获取尾节点的数据，原理与获取头结点一样，这里就不详细介绍了。

接下来我们在看看indexOf(Object o)和lastIndexOf(Object o)方法，一种是第一个匹配的索引，一个是最后一个匹配的索引，实现的在于一个从前往后遍历，一个从后往前遍历。源码如下

//获取指定元素从first开始的索引位置，不存在就返回-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;
}

//获取指定元素从first开始最后出现的索引，不存在就返回-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;
}

修改操作

接下来我们看看修改方法，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;
}

删除操作

LinkedList提供了众多删除方法，包括头删除removeFirst()、尾删除removeLast()、remove(int index)、remove(Object o)、clear()这些删除元素的方法。

首先我们先来看看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;//得到源头节点的下一个节点
f.item = null;
f.next = null; // help GC
first = next;//源头节点的下一个节点变为新的投及诶单
if (next == null)//如果不存在下一个节点，空表
last = null;
else
next.prev = null;//如果存在下一个节点，那它向前指向null
size--;
modCount++;
return element;
}

我们继续看看remove(int index)方法，源码如下

public E remove(int index) {
checkElementIndex(index);
return unlink(node(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;
}

if (next == null) {//如果后一个节点为空(如当前节点为尾节点)，当前节点前一个成为新的尾节点
last = prev;
} else {
next.prev = prev;//如果后一个节点不为空，后一个节点向前指向当前的前一个节点
x.next = null;
}

x.item = null;
size--;
modCount++;
return element;
}

我们继续看看remove(Object o)方法，源码如下

public boolean remove(Object o) {//移除列表中首次出现的指定元素(如果存在)，LinkedList中允许存放重复的元素
if (o == null) {//由于LinkedList中允许存放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;
}
}
3ff0

}
return false;
}

最后我们再来看看如何遍历LinkedList

第一种方式，通过迭代器Iterator遍历

Iterator iter = list.iterator();
while (iter.hasNext())
{
System.out.println(iter.next());
}

第二种方式，foreach循环遍历

for(String str:list)
{
System.out.println(str);
}

最后我们在总结一下LinkedList

LinkedList的实现是基于双向循环链表的，且头结点中不存放数据。

在查找和删除某元素时，源码中都划分为该元素为null和不为null两种情况来处理，LinkedList中允许元素为null。

LinkedList是基于链表实现的，因此不存在容量不足的问题，所以这里没有扩容的方法。

源码中先将index与长度size的一半比较，如果index<size/2，就只从位置0往后遍历到位置index处，而如果index>size/2，就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历，从而提高一定的效率。

LinkedList是基于链表实现的，因此插入删除效率高，查找效率低。