Collection容器初探之LinkedList

网上的LinkedList的源码分析大都为JDK1.6的版本，所以为双向循环链表的环形结构。但是JDK1.7的版本为双向链表。

先简单分析了解下JDK1.6版本的源码：

参考：

给jdk写注释系列之jdk1.6容器(2)-LinkedList源码解析

这篇博客分析的很彻底！！！赞。

JDK1.6~JDK1.7过程中，LinkedList从双向循环链表转换为双向链表

这次来简单了解和分析下JDK1.6的基于双向循环链表的实现：



继承自List,Deque,Cloneable,Serializible接口

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

双向循环链表的底层数据存储形式：

private transient Entry header = new Entry(null, null, null);
private transient int size = 0;

其中size为元素数目，header为链表的头节点，Entry为链表中的节点对象

经常使用的默认构造方法：

public LinkedList() {
//将header节点的前一节点和后一节点都设置为自身
header.next = header.previous = header;
}

Entry为LinkedList的静态内部类，定义了当前存储的节点和它相邻的两个节点：

private static class Entry {
E element;
Entry next;
Entry previous;

Entry(E element, Entry next, Entry previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}

插入：

/**
* 添加一个集合元素到list中
*/
public boolean addAll(Collection<? extends E> c) {
// 将集合元素添加到list最后的尾部
return addAll(size , c);
}

/**
* 在指定位置添加一个集合元素到list中
*/
public boolean addAll(int index, Collection<? extends E> c) {
// 越界检查
if (index < 0 || index > size)
throw new IndexOutOfBoundsException( "Index: "+index+
", Size: "+size );
Object[] a = c.toArray();
// 要插入元素的个数
int numNew = a.length ;
if (numNew==0)
return false;
modCount++;

// 找出要插入元素的前后节点
// 获取要插入index位置的下一个节点，如果index正好是lsit尾部的位置那么下一个节点就是header，否则需要查找index位置的节点
Entry<E> successor = (index== size ? header : entry(index));
// 获取要插入index位置的上一个节点，因为是插入，所以上一个点击就是未插入前下一个节点的上一个
Entry<E> predecessor = successor. previous;
// 循环插入
for (int i=0; i<numNew; i++) {
// 构造一个节点，确认自身的前后引用
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
// 将插入位置上一个节点的下一个元素引用指向当前元素（这里不修改下一个节点的上一个元素引用，是因为下一个节点随着循环一直在变）
predecessor. next = e;
// 最后修改插入位置的上一个节点为自身，这里主要是为了下次遍历后续元素插入在当前节点的后面，确保这些元素本身的顺序
predecessor = e;
}
// 遍历完所有元素，最后修改下一个节点的上一个元素引用为遍历的最后一个元素
successor. previous = predecessor;

// 修改计数器
size += numNew;
return true;
}

删除：

/**
* 删除第一个匹配的指定元素
*/
public boolean remove(Object o) {
// 遍历链表找到要被删除的节点
if (o==null) {
for (Entry e = header .next; e != header; e = e.next ) {
if (e.element ==null) {
remove(e);
return true;
}
}
} else {
for (Entry e = header .next; e != header; e = e.next ) {
if (o.equals(e.element )) {
remove(e);
return true;
}
}
}
return false;
}

private E remove(Entry e) {
if (e == header )
throw new NoSuchElementException();

// 被删除的元素，供返回
E result = e. element;
// 下面修正前后对该节点的引用
// 将该节点的上一个节点的next指向该节点的下一个节点
e. previous.next = e.next;
// 将该节点的下一个节点的previous指向该节点的上一个节点
e. next.previous = e.previous;
// 修正该节点自身的前后引用
e. next = e.previous = null;
// 将自身置空，让gc可以尽快回收
e. element = null;
// 计数器减一
size--;
modCount++;
return result;
}

查询：

/**
* 查找指定索引位置的元素
*/
public E get( int index) {
return entry(index).element ;
}

/**
* 返回指定索引位置的节点
*/
private Entry<E> entry( int index) {
// 越界检查
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException( "Index: "+index+
", Size: "+size );
// 取出头结点
Entry<E> e = header;
// size>>1右移一位代表除以2，这里使用简单的二分方法，判断index与list的中间位置的距离
if (index < (size >> 1)) {
// 如果index距离list中间位置较近，则从头部向后遍历(next)
for (int i = 0; i <= index; i++)
e = e. next;
} else {
// 如果index距离list中间位置较远，则从头部向前遍历(previous)
for (int i = size; i > index; i--)
e = e. previous;
}
return e;
}

改动：

/**
* 修改指定位置索引位置的元素
*/
public E set( int index, E element) {
// 查找index位置的节点
Entry e = entry(index);
// 取出该节点的元素，供返回使用
E oldVal = e. element;
// 用新元素替换旧元素
e. element = element;
// 返回旧元素
return oldVal;
}