LinkedList 源码阅读（二）

数据结构

继承关系

（1）继承AbstractSequentialList，提供根据索引操作数据。

（2）实现List，有序队列。

（3）实现Deque，双端队列接口，继承队列接口，支持在队列两端进行入队和出队操作。

（4）实现Cloneable，重写了clone方法。

（5）实现java.io.Serializable，支持序列化。

AbstractSequentialList 实现了get(int index)、set(int index, E element)、add(int index, E element) 和 remove(int index)这些根据索引操作数据的方法。

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

}

属性

    // 元素个数
    transient int size = 0;
    // 头结点
    transient Node<E> first;
    // 尾结点
    transient Node<E> last;

构造函数

    /**
     *  空的构造函数
     */
    public LinkedList() {
    }


    /**
     * 集合作为参数的构造函数
     */
    public LinkedList(Collection<? extends E> c) {

        //调用自身空构造函数
        this();
        //添加集合中所有的元素
        addAll(c);
    }

内部类

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

内部方法

（1）主要是LinkedList类内部自身调用的方法，也是对链表的增加和删除的操作方法。

（2）元素值为null，并不是此节点为null，下面代码中的f == null，意思是集合里面没有节点，也就是集合为空。如果存入值是null，那么会创建一个final Node<E> newNode = new Node<>(null, null, f)新节点。第二个null代表元素值为空。

   增加节点

 /**
  * 链表首部添加一个节点
  */
  private void linkFirst(E e) {
        // 保存原来头节点，final修饰不可修改
        final Node<E> f = first;
        // 创建新增节点，前驱为空，后继是原来头节点
        final Node<E> newNode = new Node<>(null, e, f);
        // 设置头节点是新增节点
        first = newNode;
        // 如果之前就没有头节点，也就是集合为空，尾节点也是新增节点，否则f节点前引用指向新增节点
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        // 节点个数 +1
        size++;
        // 修改次数 +1
        modCount++;
    }


  /**
   * 链表尾部添加一个节点
   */
   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++;
   }

   /**
     * 在任意节点之前添加一个节点
     */
    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++;
    }

  删除节点

    /**
     *  删除非空首节点
     */
    private E unlinkFirst(Node<E> f) {
        // 保存此节点的元素值
        final E element = f.item;
        // 保存此节点的后继节点
        final Node<E> next = f.next;
        // 值设置为空
        f.item = null;
        // 后引用（指针）设置为空
        f.next = null;
        // 设置首节点为下一个节点
        first = next;
        // 如果下一个节点为空，那么集合里面就一个节点，删除之后没有了，所以尾节点也设为空
        // 否则设置下一个节点的前驱为null
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        //返回节点元素值
        return element;
    }

    /**
     * 删除非空尾节点
     */
    private E unlinkLast(Node<E> l) {
        //删除头节相似
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null;
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

    /**
     * 删除任意非空节点
     */
    E unlink(Node<E> x) {
        //此节点元素值
        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;
            //此节点的前引用（指针）设置null
            x.prev = null;
        }

        //后继为空节点，即是尾节点
        if (next == null) {
            //尾节点设置为此节点的前驱节点
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        //元素值设置为空
        x.item = null;
        size--;
        modCount++;
        return element;
    }

外部方法

（1）可以被开发人员任意调用的方法，也就是一些公有增删改查的方法。

（2）外部方法的实现其实是通过调用内部方法，增加和删除方法都是调用内部方法节点的增加和删除。

（3）节点和元素区别： Node<E> newNode = new Node<>(null, e, null)

         节点里面包含元素e，还有元素前引用（指针）和后引用（指针）。

    /**
     *  获得首节点的值
     *
     * 如果集合为空，抛出 NoSuchElementException 异常
     */
    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;
    }

    /**
     * 删除首节点并返回首节点的值
     */
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        //调用内部方法
        return unlinkFirst(f);
    }

    /**
     * 删除尾节点并返回尾节点的值
     */
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        //调用内部方法
        return unlinkLast(l);
    }

    /**
     * 在集合最前面添加一个元素
     */
    public void addFirst(E e) {
        //调用内部方法
        linkFirst(e);
    }

    /**
     * 在集合最后面添加一个元素
     */
    public void addLast(E e) {
        //调用内部方法
        linkLast(e);
    }

    /**
     *  判断集合是否包含元素o
     */
    public boolean contains(Object o) {
        return indexOf(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;
    }

    /**
     *  返回集合长度
     */
    public int size() {
        return size;
    }

    /**
     *  集合添加一个元素
     *  默认添加在集合最后面添加，有序集合
     */
    public boolean add(E e) {
        //调用在尾节点后面添加一个元素
        linkLast(e);
        return true;
    }

    /**
     *  集合删除一个元素
     */
    public boolean remove(Object o) {
        //如果元素为空
        if (o == null) {
            // 遍历集合
            // 1.首节点赋值给x
            // 2.循环条件是节点不能为空，为空时候就是此处以及后面没有节点了
            // 3.把x的后引用赋给x,也就是x变为后面的节点
            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;
    }

    /**
     *  集合添加一个集合的元素
     */
    public boolean addAll(Collection<? extends E> c) {
        //调用下面方法，size 作为参数传入，就是从原来集合后面添加一个集合元素
        return addAll(size, c);
    }

    /**
     *  集合在索引值为index的节点前面添加一个集合的元素
     */
    public boolean addAll(int index, Collection<? extends E> c) {
        //检查是否越界（ index >= 0 && index <= size;）
        checkPositionIndex(index);

        //转化为数组
        Object[] a = c.toArray();
        //数组长度
        int numNew = a.length;
        if (numNew == 0)
            return false;

        // 新添加集合c的前驱，后继，
        // 添加集合的前面节点是pred，后面节点是succ
        Node<E> pred, succ;
        // 若索引是size，就是在原来集合后面添加元素
        if (index == size) {
            // 集合c的后继为 null
            succ = null;
            // 集合c的前驱为之前尾节点
            pred = last;
        } else {
            // 集合c的后继为索引为 index 的节点
            succ = node(index);
            // 集合c的前驱为索引为 index 的节点的前驱
            pred = succ.prev;
        }

        for (Object o : a) {
            // 强制类型转换
            E e = (E) o;
            // 为元素 e 创建节点
            Node<E> newNode = new Node<>(pred, e, null);
            // 前驱为 null，添加第一个元素可能前面为空
            if (pred == null)
                // 新节点设置为头节点
                first = newNode;
            else
                // 前驱的后引用指向新节点
                pred.next = newNode;
            // 前驱改为新节点，就是在新节点后面添加元素
            pred = newNode;
        }

        // 后继为null，添加的最后一个节点作为尾节点
        if (succ == null) {
            last = pred;
        } else {
            // 最后添加一个节点的后引用指向集合c的后继
            pred.next = succ;
            // 集合c的后继的前引用指向最后添加一个节点
            succ.prev = pred;
        }

        // 大小 = 原来大小 + 新添加集合的大小
        size += numNew;
        // 修改次数 +1
        modCount++;
        return true;
    }

    /**
     * 删除集合所有元素
     */
    public void clear() {

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

操作指定位置元素

  主要方法：

    /**
     * 返回指定位置 index 的元素
     */
    Node<E> node(int index) {
        // 判断index是否小于size的一半，如果小于则从头遍历节点，否则从结尾遍历节点
        // size >> 1 移位运算就是 size/2
        if (index < (size >> 1)) {
            //从首节点开始，依次将后一个节点赋给x
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            //返回index位置上元素
            return x;
        } else {
            //从尾节点开始，依次将前一个节点赋给x
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

  增删改查

    /**
     * 查询指定位置元素
     */
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    
    /**
     * 修改指定位置元素
     */
    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
    
    /**
     * 指定位置添加元素
     */
    public void add(int index, E element) {
        checkPositionIndex(index);

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

    /**
     * 删除指定位置元素
     */
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }