LinkedList源码分析

LinkedList实现了List，Deque，Cloneable，Serializable接口，具有集合，队列，克隆以及序列化功能。使用泛型在编译期提早发现类型错误。

LinkedList使用私有内部类Node保存集合中元素的信息，本例分析一些主要的方法，比如add方法，其方法内部调用了linkLast方法，那就只查看linkLast方法。

添加节点，主要是确定并设置链表首节点和尾节点以及新添加节点的位置。

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

linkFirst

头部添加元素，先定位当前要添加的元素的位置，其pre节点为null，next节点为当前的first，如果链表的首节点或者尾节点为空，那么这个链表必定为空

private void linkFirst(E e) {
        final Node<E> f = first;
        // 定位当前节点
        final Node<E> newNode = new Node<>(null, e, f);
        // 当前节点为首节点
        first = newNode;
        if (f == null)
            // 原首节点为空，添加当前节点之前集合为空，添加新节点，此时首节点和尾节点都为当前新添加节点
            last = newNode;
        else
            // 原首节点不为空，则其pre节点一定指向当前新加节点，其next节点没有变化
            f.prev = newNode;
        size++;
        modCount++;
    }

linkLast

尾部添加元素，先定位当前要添加的元素的位置，其pre节点为当前的last节点，next节点为null

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
            // 尾节点的next节点一定指向当前新加节点，其pre节点没有变化
            l.next = newNode;
        size++;
        modCount++;
    }

 addAll(int index, Collection<? extends E> c)

1、判断索引及添加的集合是否为空
2、将要添加的集合作为一个整体，获取其前驱节点pred和后继节点succ
3、将集合中的每个元素依次添加到链表中
4、处理要添加的集合的最后一个元素的next节点/链表尾部节点

public boolean addAll(int index, Collection<? extends E> c) {
        // 检测索引是否合法
        checkPositionIndex(index);

        // 要添加的集合为空，返回false
        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

        // 将当前Collection看成一个整体，为简单，称为cton,获取其前驱节点pred和后继节点succ
        Node<E> pred, succ;
        if (index == size) {
            // 在尾部添加
            succ = null;
            pred = last;
        } else {
            // 
            succ = node(index);
            pred = succ.prev;
        }
        
        // 遍历要添加的元素，确定每个元素在LinkedList中的前一个pred及succ节点，最终确定其位置
        for (Object o : a) {
            E e = (E) o;
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
        /*
         * 经过上述遍历，pred为cton中最后一个元素的节点。cton集合中size-1个元素的pred和succ节点都已经确定，
         * 但最后一个元素的next节点为null，不能够确定是否准确
         */
        if (succ == null) {
            // 后继节点为null，则以上操作结束后，除了链表的尾部节点需要调整之外，其他节点的位置都已确定。
            last = pred;
        } else {
            // cton中最后一个元素节点next节点为cton的succ节点，succ节点的pred节点为cton最后一个元素节点pred
            pred.next = succ;
            succ.prev = pred;
        }

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

 linkBefore(E e, Node<E> succ)

在某个元素前添加节点
1、获取元素的前驱节点
2、确定要添加的节点的位置
3、设置要添加元素的后继节点的前驱节点，前驱节点的后继节点

void linkBefore(E e, Node<E> succ) {
                 // 获取要添加节点的前驱节点
                final Node<E> pred = succ.prev;
                // 确定要添加节点的位置
                final Node<E> newNode = new Node<>(pred, e, succ);
                // 后继节点的前驱节点指向新添加节点
                succ.prev = newNode;
                if (pred == null)
                    // 前驱节点为空，意为在首节点添加节点，首节点为新添加节点
                    first = newNode;
                else
                    // 前驱节点的后继节点为新添加节点
                    pred.next = newNode;
                size++;
                modCount++;
            }

 getFirst/getLast

链表中维护有头部和尾部节点，获取头部或者尾部节点比较容易，直接取出首节点/尾节点对应的值即可

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

node(int)

获取指定节点的元素，二分查找，提高效率

1、判断index是否小于链表元素的一半
2、若是，则从左侧开始查找，若否，则从右侧开始查找
3、将每次查找节点重新复制给原数据，则在index-1节点获取的节点的next即为所需要的节点

Node<E> node(int index) {
            if (index < (size >> 1)) {
                // 左侧开始遍历，初始值为首节点
                Node<E> x = first;
                for (int i = 0; i < index; i++)
                    // 将当前节点的next节点重新赋值给x变量
                    x = x.next;
                // index-1位置的node节点的next即为我们所查找的节点
                return x;
            } else {
                Node<E> x = last;
                for (int i = size - 1; i > index; i--)
                    // 将当前节点的next节点重新赋值给x变量
                    x = x.prev;
                // size-(index +1)节点的prev节点为我们所查找的节点
                return x;
            }
        }

set(int index, E element)
修改指定位置元素
1、验证索引是否超出范围
2、获取index处原节点
3、将index处原节点的值设置为当前值

public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

indexOf(Object o)

从首节点遍历，查找首次出现与item值相同的节点所在位置，要查找的元素必须实现equals方法

public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

lastIndexOf(Object o)

从尾节点遍历，查找首次出现于item值相同的节点所在位置，要查找的元素必须实现equals方法

public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }

unlinkFirst
获取首节点的next节点，将首节点的next节点和item设置为null，将first设置为原首节点的next节点，原首节点的next节点的pre节点设置为null

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    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;
}

unlinkLast
获取尾节点的pre节点，将尾节点的pre及item设置为null，将尾节点设置为原尾节点的pre节点，原尾节点的pre节点的next节点设置为null

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)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

 remove(object)

1、找到要删除的元素对应的节点
2、找到该节点的前一个元素和后一个元素
3、设置前后节点的对应关系
4、将当前节点的前驱节点和后继节点以及item设置为null

public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}



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) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}