LinkedList源码分析(jdk1.7)

LinkedList

LinkedList是双向链表实现的线性表。

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

首先，它继承了AbstractSequentialList类，实现了List,Deque,Cloneable,java.io.Serializable接口

LinkedList特点

1. 元素可以为空，可以重复。实现了List接口
2. 可以当作队列来使用FIFO。实现了Deque接口
3. 可以使用clone()方法来克隆。实现了Cloneable接口
4. 可以被序列化。实现了Serializable接口

LinkedList核心源码分析

1.属性分析

//初始的大小为0
transient int size = 0;
//头节点
transient Node<E> first;
//尾节点
transient Node<E> last;

2.节点代码

private static class Node<E> {
	//value
    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 LinkedList() {
}
//通过已有集合构造链表
public LinkedList(Collection<? extends E> c) {
    this();
    //调用addAll()方法将集合中元素加入链表中
    addAll(c);
}
//addAll的API接口
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();
    //numNew保存数组a的长度
    int numNew = a.length;
    //如果集合中没有元素，插入失败，返回false;
    if (numNew == 0)
        return false;
	
    Node<E> pred, succ;
    //如果要插入的集合位置刚好是最后一个位置，即last之后
    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);
        //如果链表为null
        if (pred == null)
            first = newNode;
        //链表不为null
        else
            pred.next = newNode;
        pred = newNode;
    }
	//如果succ刚好是null，那么直接往last之后插入就行
    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }
	//更新链表大小
    size += numNew;
    modCount++;
    return true;
}
//如果要插入的位置不存在，抛出异常
 private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

4.增加

//尾插法
void linkLast(E e) {
	//l保存尾节点
    final Node<E> l = last;
    //创建一个新的节点对象
    final Node<E> newNode = new Node<>(l, e, null);  
    //尾节点为空即链表是空的，直接将头节点指向新节点
    if (l == null)  
    	first = newNode;
   	//否则的话，将尾节点的下一个节点指向新节点
    else
        l.next = newNode; 
    //当前存储的容量大小+1
    size++;
    modCount++;
}
//在指定节点succ前插入
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    //pred保存succ的前驱节点
    final Node<E> pred = succ.prev;
    //创建一个新节点保存要插入的节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    //如果前驱结点为null即succ为头节点
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}
/*
 *add方法调用了尾插法linkLast()方法
 */
public boolean add(E e) {
    linkLast(e);
    return true;
}

5.删除

/*
 *删除一个指定位置的节点
 */
public E remove(int index) {
	//检查范围
    checkElementIndex(index);
    //调用unlink方法删除
    return unlink(node(index));
}
/*
 *范围检验方法，如果不存在该节点，抛出异常
 */
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/*
 *删除第一个等于o的元素
 */
public boolean remove(Object o) {
	//如果o是null
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
    //o是不为null的值
        for (Node<E> x = first; x != null; x = x.next) {
        //遍历寻找等于o的元素，然后调用unlink()方法删除
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}
/*
 *unlink方法
 */
E unlink(Node<E> x) {
    //保存值和前驱后继节点
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
	//前驱为null，该节点是头节点
    if (prev == null) { 
    	//头节点指向下一个节点
        first = next;
    } else {//不是头节点的情况
    	//将前驱节点的后继指向下一个节点
        prev.next = next;
        //将要删除节点的前驱指向null，之后gc会回收
        x.prev = null;//gc
    }
	//如果要删除节点的下一个节点为null即是最后一个节点
    if (next == null) {
    	//将last指向前一个节点
        last = prev;
    } else {//不是最后一个节点
    	//将下一个节点的前驱指向要删除的前驱
        next.prev = prev;
        //将要删除节点的后继指向null
        x.next = null;//gc
    }
	//将值置空
    x.item = null;//gc
    //更新链表大小
    size--;
    modCount++;
    //返回x的值
    return element;
}

6.修改

public E set(int index, E element) {
	//范围检查
    checkElementIndex(index);
    Node<E> x = node(index);
    //保存旧节点的值
    E oldVal = x.item;
    //修改旧节点的值
    x.item = element;
    //将就节点的值返回
    return oldVal;
}

7.查询

public E get(int index) {
    checkElementIndex(index);
    //node(int index)方法得到要查询的节点
    return node(index).item;
}
/*
 * 传进来一个下标，返回下标所在的节点
 * 思想挺好，index在前一半从first开始向后遍历，index在后一半从last开始向前遍历
 */
Node<E> node(int index) {
    //如果index小于size/2,从first开始向后遍历
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
    //index不小于size/2，从last开始向前遍历
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

/*
 * 获取头节点
 */
 public E getFirst() {
    final Node<E> f = first;
    //如果是空链表抛出异常
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}
public E peek() {
    final Node<E> f = first;
    //如果是空链表返回null
    return (f == null) ? null : f.item;
}