Java之LinkedList源码浅析

LinkedList

优点：插入、删除元素效率高

缺点：遍历数据效率低。

本文基于JDK1.8.131的源码分析（其他版本的源码，不做表述）。

数据结构

底层实现，双向链表

1.构造方法

构造方法以及涉及到的方法：

transient int size = 0;
transient Node<E> first;
transient Node<E> last;
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;

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

与ArrayList不同，LinkedList有两个构造方法，一个无参，一个是传入一个集合的参数。无参的没有初始化什么东西；传入集合参数的构造方法，里面使用addAll方法将参数添加到LinkedList集合中了。在这里同样分析添加的方法（add(E e)），其他方法先不看。

2.添加元素方法

add(E e)方法以及涉及到的方法:

public boolean add(E e) {
linkLast(e);
return true;
}
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++;
}
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;
}
}

当使用LinkedList集合添加元素的时候，本质上并不是直接添加这个元素到集合中，而是对这个元素进行了一次封装，将其封装成Node节点，再将Node添加到集合。这样看来，LinkedList集合是将每一个元素都看成了Node，添加元素的过程也是添加Node过程。

前面说过，LinkedList是双向链表，他的每个节点都保存着Node<E> prev和Node<E> next（即每个节点都保存着指向前一个和后一个Node<E>的地址引用），这使得我们可以从第一个Node<E>的节点，一直查找next的节点，这样就能对整个队列进行正序遍历（同样可以从最后的一个节点，一直查找prev的节点，就可以从后到前进行倒序遍历）。

上边的添加元素的方法，首先将这个元素e封装成Node<E> newNode ，因为是将元素添加到链表的尾部，所以这个new Node的第三个参数传入null；其次将last赋值给l变量，这个last（全局变量）指的是链表的最后一个节点，因为要在尾部添加新的节点，所以last指向newNode节点（这里有个if else 判断，这个情况是size是0的时候，LinkedList添加第一个元素，first和last都指向newNode）；最后是维护链表的大小(size)。

3.删除方法

删除方法remove(int)：

public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
Node<E> node(int 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) {
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;
}

在删除元素的时候，会首先检查index的大小是否正好在LinkedList的size内（否则会抛出IndexOutOfBoundsException异常）；其次linkedList会先找出元素所在的那个节点；最后将这个节点进行删除。

node(int)方法按index查找节点；会先根据index与linkedList size的一半比较大小，如果小于，就从头开始查找；大于就从尾部开始查找（与之前的方法相比，jdk8做了优化）。

删除方法(unlink)。链表中的删除，可以理解为解除关联。比如1、2、3；三个元素，删除2这个元素，只需要将1元素的next节点指向3，将3元素的prev指向1，再把2所在的节点的元素置空即可。unlink方法大意如此。

从上面分析add(e)和remove(index)方法，也可以看出添加删除的效率要比ArrayList高，因为LinkedList不需要维护角标，元素的位置不需要移动。
addAll和removeAll不再赘述分析，这两个方法和我们分析上面的原理一致。

附录：

ArrayList与LinkedList效率差别

@Test
public void testLV(){
long a = System.currentTimeMillis();
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("1");
linkedList.add("2");
for (int i =0;i< 1000000;i++){
linkedList.add(1,"A "+i);
}
long b = System.currentTimeMillis();
System.out.println(b -a);

long c = System.currentTimeMillis();
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("1");
arrayList.add("2");
for (int i =0;i< 1000000;i++){
arrayList.add(1,"A "+i);
}
long d = System.currentTimeMillis();
System.out.println(d - c);
}

每次插入都从1的位置插入。

结果：

第一次
LinkedList使用时间:  193
ArrayList使用时间:  127495
第二次
LinkedList使用时间:  179
ArrayList使用时间:  128867
第三次
LinkedList使用时间:  184
ArrayList使用时间:  130904

插入的数据越多，ArrayList维护的角标也越多，所以效率低。