LinkedList源码解析

疑问： clear()方法中对每个节点信息都进行清理操作，这样做的必要性是什么？

一.定义

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

继承自抽象类AbstractSequentialList，

实现Deque，表明该类实现了双端链表的功能

实现Cloneable，表明覆盖clone()方法以实现浅克隆

实现Serializable，表明改类可被序列化及反序列化

下面来看下抽象类AbstractSequentialList

/*
* 扩展自AbstactList
* AbstactList主要支持随机快速访问，
* AbstractSequentialList主要支持“连续访问”，底层为链表
* 类中的get,set,add,remove等方法都是通过listIterator来进行操作
* addAll时也通过迭代一条一条一条增加，效率与ArrayList的system.copyarraycopy相比应该有差距
*/
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
protected AbstractSequentialList() {
}

public E get(int index) {
try {
return listIterator(index).next();
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}

public E set(int index, E element) {
try {
ListIterator<E> e = listIterator(index);
E oldVal = e.next();
e.set(element);
return oldVal;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}

public void add(int index, E element) {
try {
listIterator(index).add(element);
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}

public E remove(int index) {
try {
ListIterator<E> e = listIterator(index);
E outCast = e.next();
e.remove();
return outCast;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}

public boolean addAll(int index, Collection<? extends E> c) {
try {
boolean modified = false;
ListIterator<E> e1 = listIterator(index);
Iterator<? extends E> e2 = c.iterator();
while (e2.hasNext()) {
e1.add(e2.next());
modified = true;
}
return modified;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}

public Iterator<E> iterator() {
return listIterator();
}

public abstract ListIterator<E> listIterator(int index);
}

接口Deque是对Queue的扩展。

Queue是一个基本的队列接口，提供了队列插入，删除，查看方法，但对每个方法都有两种形式，一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。如图：



Deque是一个基本的双端队列接口，提供了头部插入，尾部插入，头部删除等方法，同Queue一眼，每个方法都有两种形式。如图：

//不建议允许null值插入Deque的实现类，因为各种方法可能通过null为标识来判断Deque是否为空
public interface Deque<E> extends Queue<E> {
/**
* 删除从头开始，第一个匹配的元素
*/
boolean removeFirstOccurrence(Object o);

/**
* 删除从尾开始，第一个匹配的元素
*/
boolean removeLastOccurrence(Object o);

//返回一个逆向迭代器，默认修饰符修饰
Iterator<E> descendingIterator();
public int size();
boolean contains(Object o);
//其他方法略
}

二、底层实现

就是最基本的双向链表

三、变量及构造器

transient int size = 0;

transient Node<E> first;

transient Node<E> last;
public LinkedList() {
}

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

发现三个变量都拿transient 来修饰了，说明LinkedList应该也自定义了自己的序列化方法，翻到最后，果不其然。

private static final long serialVersionUID = 876323262645176354L;

private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();

// Write out size
s.writeInt(size);

// Write out all elements in the proper order.
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}

@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();

// Read in size
int size = s.readInt();

// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}

四，基本逻辑方法

/**
*private, 只在本类中被调用
*/
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
//size为0，first和last都为newNode
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}

/**
* linkFirst private修饰，linkLast 默认修饰符，什么原因？
*/
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
//size为0，first和last都为newNode
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}

/**
* 默认修饰符
*/
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)
//succ为first，即第一个元素时，将newNode赋值于fitst
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}

/**
* private  仅供此类使用
* 删除第一个元素f，且返回实际包含元素f.item
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
//赋值为null,供GC回收
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
//删除后，没有元素时，last赋值null
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}

/**
* private  仅供此类使用
* 删除最后一个元素f，且返回实际包含元素f.item
*/
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
//删除后，没有元素时，fitst赋值null
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}

/**
* 默认修饰符
* 删除最元素f，且返回实际包含元素f.item
*/
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) {
//x为first元素时，first赋值next
first = next;
} else {
prev.next = next;
x.prev = null;
}

if (next == null) {
//x为last元素时，last赋值ptev
last = prev;
} else {
next.prev = prev;
x.next = null;
}

//x既为last又为first时，我们发现在上述处理中fist=next=null,last=prev=null
x.item = null;
size--;
modCount++;
return element;
}

我们看到这些逻辑方法中有的是private修饰很好理解，而默认修饰符修饰的原因看到下面就会发现：原来迭代器类ListItr类中也有采用。

五、get,set,add,remove

这些方法基本都很好理解，再此处贴出几个模糊的地方

1.LinkedList实现了Deque接口，在上面Deque接口介绍中我们了解到，Deque对每个插入，查找，删除方法都有两种形式，一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。而我们看LinkedList的代码中的addFirst(),allLast(),offerFirst()等方法中得到了很好的体现。这种思想值得借鉴，一个抛异常，一个返回特殊值。

2.addAll方法，是把多个元素逐个添加，相比ArrayList的system.arrayCopyf，效率十分低下。

/**
* 添加元素的顺序于Collection迭代器顺序一致
* 批量添加多个元素时，linkedList效率及其低下
*/
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)
//perd为空，即传入的index为0,要插入的元素赋值于fitst
first = newNode;
else
pred.next = newNode;
pred = newNode;
}

if (succ == null) {
//succ为空，即传入的index==size，
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}

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

3.没有覆盖抽象类中的批量remove等方法。**LinkedList对批量操作数据的效率不高。**

六、clear()方法

/**
* 需要一步一步的清空每个Node，
* 把first,last的node信息清空，其他节点交给GC不可以吗？
*/
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++;
}

需要将每个节点的数据都清空，为什么不只将first和last清空，这样其他节点没有对象引用，GC不是就自动回收？

关于这个问题，参考http://www.iteye.com/problems/71569，我是暂时没有理解，可能对JVM的了解太少，先留个坑吧。

七、clone及toArray

@SuppressWarnings("unchecked")
private LinkedList<E> superClone() {
try {
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}

public Object clone() {
LinkedList<E> clone = superClone();

// 先清空数据
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;

// 将元素一个一个赋值
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);

return clone;
}
//与ArrayList 基本相同
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}

//与ArrayList 基本相同
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;

if (a.length > size)
a[size] = null;

return a;
}

八.迭代器

public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}

/**
* 通过使用ListItr来代理，这个想法好，
* 值提供了迭代器基本的三个方法hasNext(),next(),remove()
*/
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}

总结：

1.Deque接口中对每个方法的都有两种形式的实现，一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。这种思想值得借鉴。

2.LinkedList 对批量操作效率低下

3.生成反向迭代器时，使用代理，很好的实现啊