java（7）LinkedList源码

系统环境 JDK1.7

LinkedList的基本结构 ：在JDK1.6中LinkedList是双向引用的环形结构，JDK1.6中是双向引用的线性结构

提醒：看链表代码时最好用笔画下链表结构 有助于理解代码

成员变量

//存放当前链表有多少个节点
transient int size = 0;
//为指向链表的第一个节点的引用
transient Node<E> first;
//为指向链表的最后一个节点的引用
transient Node<E> last;

构造方法

1.不带参数的构造方法
public LinkedList() {
}

2.带参数Collection的构造方法
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}  

//具体实现是通过 addAll(size, c)方法
public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}    

addAll(size, c)方法

public boolean addAll(int index, Collection<? extends E> c) {
    // 检查传入的索引值是否在合理范围内
    checkPositionIndex(index);
    // 将给定的Collection对象转为Object数组
    Object[] a = c.toArray();
    int numNew = a.length;
    // 数组为空的话，直接返回false
    if (numNew == 0)
        return false;
    // 数组不为空
    Node<E> pred, succ; 

    if (index == size) {
        // 构造方法调用的时候，index = size = 0，进入这个条件。
        succ = null;
        pred = last;
    } else {
        // 链表非空时调用，node方法返回给定索引位置的节点对象
        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; // 将当前链表最后一个节点赋值给last
    } else {
        // 链表非空时，将断开的部分连接上
        pred.next = succ;
        succ.prev = pred;
    }
    // 记录当前节点个数
    size += numNew;
    modCount++;
    return true;
}

注：这段代码分为了2种情况，一个是原来的链表是空的(index == size)，一个是原来的链表有值

//内部类Node
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;
    }
}

总结：对于两种构造方法可以概括为：无参构造为空实现。有参构造传入Collection对象，将对象转为数组，并按遍历顺序将数组首尾相连，全局变量first和last分别指向这个链表的第一个和最后一个。

addFirst/addLast分析

public void addFirst(E e) {
    linkFirst(e);
}  

private void linkFirst(E e) {
    final Node<E> f = first;                        // f 指向原链表首节点
    final Node<E> newNode = new Node<>(null, e, f); // 创建新的节点，新节点的后继指向原来的头节点
    first = newNode;                                // first 指向新创建的节点
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;                           // 原链表首节点的prev指向创建的新节点
    size++;
    modCount++;
}

//同addFirst()类似
public void addLast(E e) {
    linkLast(e);
}

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

get方法

public E get(int index) {
    // 校验给定的索引值是否在合理范围内
    checkElementIndex(index);
    return node(index).item;
}  

Node<E> node(int index) {
    //判断给定的索引值
    //若索引值大于整个链表长度的一半，则从后往前找
    //若索引值小于整个链表的长度的一般，则从前往后找
    //整数右移一位 相当除2
    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;
    }
}

整理自《http://blog.****.net/zw0283/article/details/51132161》