数据结构---linkedlist源码分析

LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的，是线程不安全的，允许元素为null的双向链表。

变量分析

       // 默认元素数量是0
        transient int size = 0;
        
       //头结点
        transient Node<E> first;
        
       //尾节点
        transient Node<E> last;

构造方法分析

    //默认是无参构造方法
    public LinkedList() {
    }
    
    //有参构造，传入一个集合，还是调用无参构造，在将集合添加到链表中
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

添加元素（默认是构造一个空链表）

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

接下来

         public boolean addAll(int index, Collection<? extends E> c) {
                checkPositionIndex(index); //检查下标是否合理  index >= 0 && index <= size;
        
                Object[] a = c.toArray();
                int numNew = a.length;  // 要添加集合的长度
                if (numNew == 0)  //空集合则添加失败 返回false
                    return false;
        
                Node<E> pred, succ;  //前驱 后继
                if (index == size) { //判断要添加的位置是否在链表末尾
                    succ = null;  //在则该集合前驱是原来尾节点，后继指向null
                    pred = last;  
                } else {
                    succ = node(index); //否则则根据下标找到指定节点，该集合后继就是该节点
                    pred = succ.prev;  //前驱则是找出来那个节点原来的前驱节点
                }
               
                // 链表批量增加，是靠for循环遍历原数组，依次执行插入节点操作
                for (Object o : a) {
                    @SuppressWarnings("unchecked") E e = (E) o;
                   // 前置节点为pred，后置节点为null，当前节点值为e的节点newNode
            Node<E> newNode = new Node<>(pred, e, null);
            // 如果前置节点为空， 则newNode为头节点，否则为pred的next节点
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
    
        // 循环结束后，如果后置节点是null，说明此时是在队尾追加的
        if (succ == null) {
            // 设置尾节点
            last = pred;
        } else {
        //否则是在队中插入的节点 ，更新前置节点 后置节点
            pred.next = succ;
            succ.prev = pred;
        }
    
        // 修改数量size
        size += numNew;
        //修改modCount
        modCount++;
        return true;
    }

根据下标查找指定节点

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

检测index位置是否合法

    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index))
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
 检测index位置是否合法

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    } 

从头部添加元素

     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  //非空则原来头结点的前驱为刚构造的节点
                f.prev = newNode;
            size++;  //修改大小
            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) {
        // assert succ != null;
        // 拿到succ的前驱
        final Node<E> pred = succ.prev;
        // 新new节点：前驱为pred，值为e，后继为succ
        final Node<E> newNode = new Node<>(pred, e, succ);
        // 将succ的前驱指向当前节点
        succ.prev = newNode;
        // pred为空，说明此时succ为首节点
        if (pred == null)
            // 指向当前节点
            first = newNode;
        else
            // 否则，将succ之前的前驱的后继指向当前节点
            pred.next = newNode;
        size++;
        modCount++;
    }

从头部删除节点

    private E unlinkFirst(Node<E> f) {
			//取出头结点和其后继，将其后继指定为新的头结点，原头结点指向null
            // 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;
        }

从尾部删除（原理相似）

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

删除指定元素

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