LinkedList源码分析

LinkedList类图

LinkedList是java.util包下的Collection接口下的一个子类，也是我们常用的容器，底层是一个双向链表，也可以当做双端无界队列使用，而我们知道，双端队列其实也相当于一个栈，因此LinkedList其实是一个具有多种功能的容器。

• AbstractSequentialList抽象类：AbstractList的子类，实现一些集合的通用的方法（添加、获得等，通过迭代器实现，隐藏了对下标的操作）。
• Cloneable接口：实现对象拷贝必须要实现的接口。
• Serializable接口：实现序列化必须要实现的接口。
• Deque接口：Queue接口下的一个子接口，扩展了队列相关的操作。

LinkedList属性

以上便是LinkedList的属性，下面一一介绍：

size

    transient int size = 0;

链表里元素的个数。

first

    transient Node first;

链表的头结点。

last

    transient Node last;

链表的尾节点。

注意：以上三个属性都是被transient关键字修饰，表示不可被序列化。LinkedList的序列化是通过反射调用重写的readObject方法和writeObject方法实现的，之所以如此做是为了只序列化存储的数据。（具体可以参考别的博客）

serialVersionUID

    private static final long serialVersionUID = 876323262645176354L;

序列化ID

Node

    private static class Node {
        E item;
        Node next;
        Node prev;

        Node(Node prev, E element, Node next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

LinkedList的一个static内部类，链表里的每个节点都是通过Node来存储的，包含item，next，prev三个属性，item用来存储值，next用来存储后指针，prev用来存储前指针。

LinkedList常用API

    public LinkedList() {
    }

    public LinkedList(Collection c) {
        this();
        addAll(c);
    }

构造方法：

• 空参的构造方法什么都没有做，只是实例化first和last两个Node节点
• 带Collection参数的构造方法首先调用空参构造方法，然后调用addAll方法来将Collection集合添加进链表中。

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

    void linkLast(E e) {
        final Node l = last;
        final Node newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

add方法：向链表中插入一个元素

add方法会调用linkLast方法，该方法是在链表的最后插入一个元素。

• 首先将尾节点保存起来（l）
• 然后创建值为e的新节点，将之前的尾节点设置为它的前指针
• 将新节点作为现在尾节点
• 判断之前的尾节点是否为null，即是否是第一次添加节点，如果是，则链表的首节点也是新节点，如果不是，将之前的尾节点的后指针指向现在的尾节点

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

    E unlink(Node x) {
        // assert x != null;
        final E element = x.item;
        final Node next = x.next;
        final Node 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方法：移除指定元素。

• 首先遍历链表，如果没有找到该元素，直接返回false
• 如果找到该元素，则调用unlink方法将该元素移除
  • 先将该元素的前后指针保存下来
  • 然后判断该元素是否是首节点，如果是首节点，则将他的下一个节点当做首节点，如果不是，则将上一个节点的后指针指向它的下一个节点，将他的前指针置为null
  • 然后判断该元素是否是尾节点，如果是尾节点，则将他的前一个节点当做尾节点，如果不是，则将下一个节点的前指针指向他的上一个节点，将他的后指针置为null
  • 将他的值置为null（方便GC回收），size--，modcount++，modcount指的是修改的次数，与迭代器遍历有关

    public boolean addAll(Collection c) {
        return addAll(size, c);
    }

    public boolean addAll(int index, Collection c) {
        checkPositionIndex(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        if (numNew == 0)
            return false;

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

addAll方法：将一个Collection集合的元素添加到链表里。

第一个addAll方法会调用带下标的addAll方法，表示将元素要插入的位置，因此addAll默认是将元素全部插入链表尾。

• 首先调用checkPositionIndex方法来检查下标是否合理（>=0且<=size），如果不合理，抛出异常
• 然后将collection集合转化为数组，判断数组里元素个数，如果为0则直接返回false
• 然后初始化两个Node，这两个节点可以用来判断要插入的位置
• 遍历数组，将元素全部插入
• 根据之前初始化的两个Node来判断是插入链表尾还是插入其余位置，然后更新相应的头结点或者尾节点
• 更新size个数，modcount++

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

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

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

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

addFirst方法：在链表头部加入一个节点

addLast方法：在链表尾部加入一个节点

removeFirst方法：删除链表头部第一个元素

removeLast方法：删除链表尾部第一个元素

linkLast和linkFirst方法之前介绍过，这里不再赘述。

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

 Node node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

get方法：获得指定下标的元素。

• 首先调用checkElementIndex方法来验证下标是否合理
• 然后调用node方法来获得指定下标的元素
  • 首先size右移一位，即size除以2，获得元素的中间下标
  • 如果index
  • 反之index>mid，则要查找的下标离尾节点更近，从尾节点遍历查找

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

set方法：修改指定下标的元素值。

• 首先调用checkElementIndex方法来验证下标是否合理
• 然后调用node方法来获得指定下标的元素
• 然后更新该元素并返回旧的元素值

   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 x = first; x != null; ) {
            Node next = x.next;
            x.item = null;
            x.next = null;
            x.prev = null;
            x = next;
        }
        first = last = null;
        size = 0;
        modCount++;
    }

clear方法：清空链表。

• 遍历链表，所有属性置为null（方便GC回收）
• 头结点和尾节点置为null，size归零，modcount++

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

contains方法：判断列表中是否存在某个元素。

调用indexOf方法来查找该元素，如果不存在，返回下标为-1

indexOf方法：从头结点开始遍历，如果找到，返回对应下标，如果没找到，返回-1

    public int size() {
        return size;
    }

size方法：返回当前链表中的元素个数。

 

================================================================================================

=======================  以上方法均是操作链表的方法  以下方法用来操作队列  ===============================

================================================================================================

 

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

poll方法：弹出队列元素，从链表头部取出，如果是空链表则返回null，会将链表头结点删除

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

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

pop方法：弹出队列元素，从链表头部取出，如果是空链表则会抛出异常，会将链表头结点删除

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

peek方法：查看队头元素，从链表头部取出，如果是空链表则会返回null，不会将链表头结点删除

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

push方法：向队列中添加一个元素，从链表的头部插入

总结

• LinkedList底层是一个双向链表。
• LinkedList还实现了Queue的子接口Deque，实现了一些队列的方法，因此他还是一个双端无界队列，而双端无界队列也可以用来当做栈使用。
• LinkedList在队列首尾添加元素非常高效，时间复杂度为O(1)，在中间添加删除的时间复杂度为O(n)。
• LinkedList为了性能考虑，一方面在删除元素或者清空链表时，不只是将链表切断，而且会将切除的Node节点全部置为null，方便GC回收，另一方面，他实现了序列化接口，但又将存储数据的前指针、后指针、元素个数等属性设置为transient，禁止自动序列化，而是通过实现readObject和writeObject方法来只序列化实际存储的数据，减少空间的占用。