JDK源码解析---LinkedList

1.概述

LinkedList ，是基于节点实现的双向链表的 List ，每个节点都指向前一个和后一个节点从而形成链表。
LinkedList提供队列、双端队列、栈的功能。
LinkedList随机访问的平均时间复杂度为O(n)，查找指定元素的平均时间复杂度为O(n)。
LinkedList移除指定位置的元素的最好时间复杂度是O(1)，最坏时间复杂度是O(n)，平均是O(n)。
LinkedList 添加元素的最好时间复杂度是O(1) ，最坏时间复杂度是O(n) ，平均时间复杂度是O(n)

LinkedList不仅可以在链头链尾添加删除元素，还可以在中间部分添加删除元素。只是要找到指定的元素需要遍历链表

2.类图

实现了3个接口，其中如下三个与ArrayList一致：

• java.util.List 接口
• java.io.Serializable 接口
• java.lang.Cloneable 接口
  而java.util.RandomAccess 接口没有实现，不同于ArrayList很大一点，不支持随机访问。
  而java.util.Deque 接口是多于ArrayList的。提供双端队列的功能，LinkedList 支持快速的在头尾添加元素和读取元素，所以很容易实现该特性。

3.属性

• transient int size = 0;//链表的大小
  

• transient Node<E> first;//指向头结点的指针
  

• transient Node<E> last;//指向尾结点的指针
  

4.构造方法

• LinkedList()
  构造一个空的链表

    public LinkedList() {
    }

• LinkedList(Collection<? extends E> c)
  构造一个包含集合C中元素的链表。需要使用到无参构造函数，然后调用添加左右的方法，将集合C中的元素添加到链表中。

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

因为没有容量一说，所以没有向ArrayList一样有一个参数为容量大小的构造函数。当然也就不存在扩容和缩容的问题。

5.添加元素

添加元素的操作相对于ArrayList来说，不需要考虑容量的问题。

5.1添加单个元素

• offerFirst(E e)
  调用 addFirst(e)，返回True

    public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

• addFirst(E e)
  头插法，调用linkFirst(E e)

  这个方法和上面提到的方法唯一的区别就在于一个有返回值一个没有返回值。

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

• push(E e)
  调用addFirst(e);

  其实和addFirst没有差别。只是为了提供一个常规的名字push

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

• linkFirst(E e)
  在头部添加元素，头插法。首先声明一个指针指向头结点，设置一个新的结点保存元素e。若头指针为空，则尾指针指向新的结点。否则头结点的前驱指向新的结点。属性size加1，修改次数加一。

    private void linkFirst(E e) {
        final Node<E> f = first;//指向头节点。
        final Node<E> newNode = new Node<>(null, e, f);//根据传入的参数构建新的节点。前驱为null 后继为f。
        first = newNode;//头指针first指向这个节点。
        if (f == null)//若原先没有头节点
            last = newNode;//则将尾指针也指向这个新的节点。
        else //否则原先的头节点的前驱指向这个新的节点。
            f.prev = newNode;
        size++;
        modCount++;
    }

• offerLast(E e)
  调用addLast(E e)，返回true

    public boolean offerLast(E e) {
        addLast(e);
        return true;
    }

• addLast(E e)
  尾插法，调用linkLast(E e)

    public void addLast(E e) {
        linkLast(e);
    }

• offer(E e)
  调用add(E e)。

    public boolean offer(E e) {
        return add(e);
    }

• add(E e)
  添加元素，是使用尾插法，调用linkLast(E e)有返回值true。

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

• linkLast(E 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++;
    }

• linkBefore(E e, Node succ)
  在指定元素succ之前插入元素e。
  首先获取succ的前一个节点。创建新节点newNode，设置succ的前一个节点为新节点。如果prev为null，说明first为空，则first指向新的节点。
  若pred非空，说明first不为空，pred的后继指向新节点。增加链表大小，增加修改次数。
  

    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)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

• add(int index, E element)
  指定位置插入元素
  首先检查是否越界。若index等于链表大小，则调用linkLastlinkLast(element)尾插法，否则调用linkBefore(element, node(index)),在指定节点前插入元素。

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

		Node<E> node(int index) {//找到索引index的节点。
        // assert isElementIndex(index);

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

5.2添加多个元素

• addAll(Collection<? extends E> c)
  将集合C中的元素添加到链表中，调用addAll(int index, Collection<? extends E> c)。

    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

• addAll(int index, Collection<? extends E> c)
  首先检查参数index有没有越界，超出链表范围。将集合c转为对象数组。求出对象数组的长度，若长度为0，则返回false。
  声明两个指针pred，succ。判断参数index是否等于size，若等于则将succ设为null，pred设为last。否则succ指向第index结点。pred指向succ的前驱。
  遍历对象数组，创建新的结点newNode。若pred为空，则first头指针指向newNode，否则pred的后继指向newNode。修改pred指向newNode。类似尾插法。
  若succ为null，则尾指针指向pred。否则pred的后继指向succ，succ的前驱指向pred。
  链表大小加numNew，即加上集合C的大小。
  修改次数加一。

说简单点就是当index等于链表长度的时候，将c集合中的元素一个接一个的添加到链尾。若index小于链表长度的时候，则找到索引index的节点。在这个节点之前插入集合c中的所有元素。

    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)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

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

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

6.删除元素

• remove()
  删除头结点。调用removeFirst()；

    public E remove() {
        return removeFirst();
    }

• removeFirst()
  删除头结点元素。
  首先获取头结点，若为空则抛出异常，不为空则调用unlinkFirst(Node f)

    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

• pop()
  调用removeFirst()

    public E pop() {
        return removeFirst();
    }

• unlinkFirst(Node f)
  删除头结点元素，过程如图所示。
  首先设置element接收要删去节点的属性，设置指针next指向要f的后继，将节点f的属性以及后继设置为null，可以帮助垃圾回收器回收。修改头指针指向next，即原来头结点的后一个节点。若nuxt为空，则尾指针设为空，否则，next的前驱设为空。链表大小减一，修改次数加一。
  

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

• removeLast()
  删除尾结点。
  首先获得尾指针指向的结点，若为空则抛出异常，否则调用unlinkLast(Node l)

    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

• unlinkLast(Node l)
  删除尾结点元素，过程如图所示。
  首先设置遍历element来接收要删去的节点的属性。设置prev指向l的前驱，将要删去的节点的属性和前驱设为空，帮助垃圾回收。尾指针last修改为prev，即原来尾节点的前一个节点。若prev为空，则头指针设空，否则prev的后继设为空。链表大小减一，修改次数加一。
  

    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 o)
  移除指定对象o
  遍历链表，找到对象o然后调用unlink(Node x)

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

• unlink(Node x)
  删除指定节点x。
  首先设置变量element保存要删去节点的属性，分别设置两个指针指向删去节点的前驱prev与后继next。
  若prev为null，则头指针指向next，否则，prev的后继指向next，x的前驱设为null。
  若next为null，则尾指针指向prev，否则，next的前驱指向prev，x的后继设为null。x的属性设为空。链表大小减一，修改次数加一。

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

• remove(int index)
  删除指定第index个元素。首先检查是否越界，调用node函数获得结点再然后调用unlink函数，删除指定节点。

    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

• clear()
  清空链表，遍历链表，逐一删除。

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

7.获取元素

• element()
  调用getFirst(),获取头部结点。

    public E element() {
        return getFirst();
    }

• getFirst()
  首先获取头指针指向的结点，若为空则抛出异常，否则获取链表中的第一个元素。

    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

• getLast()
  首先获取尾指针指向的结点，若为空则抛出异常，否则获取链表中的最后一个元素。

    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

• get(int index)
  获取指定第index个元素。首先检查是否越界，然后调用node(int index)

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

• node(int index)
  判断index的大小选择从头开始找还是从尾开始找。

    Node<E> node(int index) {
        // assert isElementIndex(index);

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

8.判断是否包含某元素

• contains(Object o)
• 调用indexOf(Object o)

    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }

• indexOf(Object o)
  从头遍历链表，找到与对象o一样的属性。若找到了则返回其索引。否则返回-1.

    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)
  从尾部开始遍历，找到与对象o一样的属性。若找到了则返回其索引。否则返回-1。

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

• peek()
  检索头结点，判断是否为null，返回其值。不删除头结点。1.5是这样写的

    public E peek() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

• peekFirst()
  检索头结点。同上面功能一样。1.6是这样写的

    public E peekFirst() {
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }

• peekLast()
  检索尾结点，返回其值。

    public E peekLast() {
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

• pollLast()
  检索尾结点，判断是否为空，若为空则返回null，否则调用unlinkLast(l)。

    public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

• poll()
  检索头结点，判断是否为null。若不为null，则删除头结点。

    public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

• pollFirst()
  检索头结点，判断是否为空，若为空则返回null，否则调用unlinkFirst(f)；1.6

public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

9.计算链表长度

直接返回size属性

    public int size() {
        return size;
    }

10.修改元素

• set(int index, E element)
  修改指定位置的元素，首先检查是否越界，然后调用node(index)，获得结点。修改该结点的元素。返回原先的值。

11.序列化链表

• writeObject(java.io.ObjectOutputStream s)
  写入非静态属性，写入非transient属性，写入链表大小，顺序遍历，逐个序列化

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

12.反序列化链表

• readObject(java.io.ObjectInputStream s)
  读取非静态属性，非transient属性，读取size，顺序遍历，逐个反序列化。

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

13.克隆

• clone()
  调用父类的克隆方法，重置clone为初始化状态，顺序遍历，逐个添加到clone中

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

        // Put clone into "virgin" state
        clone.first = clone.last = null;
        clone.size = 0;
        clone.modCount = 0;

        // Initialize clone with our elements
        for (Node<E> x = first; x != null; x = x.next)
            clone.add(x.item);

        return clone;
    }