浅析Java源码之LinkedList

　　可以骂人吗？？？辛辛苦苦写了2个多小时搞到凌晨2点，点击保存草稿退回到了登录页面？？？登录成功草稿没了？？？喵喵喵？？？智障！！气！

　　很厉害，隔了30分钟，我的登录又失效了，草稿再次回滚，不客气了，***！

　　仔细想想，自动保存功能也挺可疑的，根据我半年的资深前端经验判断，内部实现大概是这样：

var id;
　　// *core event*
window.addEventListener('keyup',function(){
　　　　 if(id){clearTimout(id);}
id = setTimeout(function(){
// user would be relieved to see this...
$('#...').html('本地自动保存于' + (new Date()).toLocaleTimeString() + ',<a href="javascript:void(0);">查看</a>')
},1000*Math.random());
});

　　如此智能的功能只能用这样优雅的代码实现了吧，社会社会！

　　重写。

 

　　上篇讲完了ArrayList，这篇继续补完LinkedList的内容。

　　首先上一张图来整体看一眼链表的结构(还好图在)：

　　每一个大方块代表一个节点(Node)，内部包含3部分内容：

1、前指针：指向上一个节点，头部元素指向null

2、数据：保存的数据内容

3、后指针：指向下一个节点，尾部元素指向null

　　Node是一个类，而且是一个私有+静态+内部类，buff齐全，看一眼实现：

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

　　非常简单暴力，3个变量，一个构造函数，没啥解释的。

 　　

　　老规矩，首先从变量开始看起。

变量

public class LinkedList<E> extends AbstractSequentialList<E> implements
List<E>, Deque<E>, Cloneable, java.io.Serializable {

transient int size = 0;
transient Node<E> first;
transient Node<E> last;
}

　　3个变量，size代表当前链表长度，first与last分别指向头部与尾部节点。

 

构造函数

 　　有两个构造函数：

public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}

　　其中无参构造函数啥事也不做，另外一个构造函数允许以指定集合初始化链表。

　　这里的addAll只是一个重载版本

public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}

　　指向真正的addAll，在指定的位置插入链表，初始化的话size为0

public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}

　　直接看addAll的源码：

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

　　函数比较长，主要分为4步：

1、索引合法性检测

2、将集合拆分为数组并检测长度，如果为0不做操作直接返回false

3、根据插入位置分情况做插入

4、插入操作

 

　　首先第一步，比较简单：

private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}

　　判断插入索引是否在允许范围内，抛异常。

 

　　第二步的插入分两种：

1、尾部插入

2、其他

　　先看尾部插入的情况，即size==index：

succ = null;
pred = last;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;
}

　　在for循环中，每次都会生成一个新的Node，前指针指向pred(第一个为链表尾元素)，数据为类型转换后的集合元素。

　　然后将pred的尾指针指向新生成的节点，最后将pred置为该节点。

　　依次插入集合元素后，由于是尾部插入，所以last应该是最后插入的元素，即last=pred。

　　

　　第二种情况是中间插入，详细过程就不写了，心情有点糟糕。

 

方法

　　有了addAll，其他的方法就很简单了。

 getFirst/Last

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

public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}

　　两个get方法分别返回链表的头部与尾部元素，判断是否存在并返回对应的item。

　　

remove

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

public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}

　　两个删除方法也分别移除头部与尾部元素，方法就看一下unlinkFirst够了。

private E unlinkFirst(Node<E> f) {
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;
}

　　这里将头部数据先缓存起来，然后将头部元素移除，将首元素设置为第二个节点，将第二个节点的prev置null。

　　如果第二个节点为null，说明链表中没有元素了，于是last也置null。

 

getIndex

　　最后看一下获取指定索引的数据

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

　　这里不是单纯的从头遍历，而是做了一个小判断，如果索引在前半截，则从头往后遍历，否则相反。这样就将时间复杂度降低到o(n/2)，但是只有双向链表才有。

　　剩余的方法都没有什么营养，有兴趣的可以自行研究，画画图简单的很。

 

　　最后总结一下ArrayList与LinkedList。

1、两者都是基本的容器，可以按顺序存储元素而且不用担心容器大小

2、搜索上ArrayList由于底层是数组，所以时间复杂度为o(1)，而LinkedList为o(2/n)

3、插入元素时，ArrayList需要考虑扩容、变动索引后面元素，而链表最多只需要变动2个节点

4、虽然总体看起来ArrayList更弱，但是链表Node本身的复杂度也不容忽视，如果只为了读取还是尽量用ArrayList。