LinkedList运行原理

LinkedList和ArrayList都闲了List接口。因为LinkedList基于链表结构，所以插入，删除某一个节点会比ArrayList效率高，但随即访问某一个元素，效率不如ArrayList。
因为是链表结构，所以在初始化的时候不需要连续的内存，只需要见缝插针，记录next，prev就可以。所以在空间复杂度上比ArrayList强。

//LinkedList的Add过程
 public boolean add(E e) {
        //从方法命名可以看出在链表的尾端
        linkLast(e);
        return true;
    }

 /**
     * 链接一个元素到链表末端
     */
    void linkLast(E e) {
        //获取最后一个节点位置
        final Node<E> l = last;
        //传入参数前一个节点位置，元素，下一个节点
        //因为插入到链表末端，所以没有next
        final Node<E> newNode = new Node<>(l, e, null);
        //将最后一个节点指向新的元素
        last = newNode;
        //如果链表没有最后一个元素，说明链表为空
        if (l == null)
            //将新的元素作为第一个元素插入
            first = newNode;
        else
            //将之前最后一个元素的next指向新的Last
            l.next = newNode;
        //长度增加
        size++;
        modCount++;
    }
    //Node内部类
      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;
        }
    }

再来看根据index去get一个元素

 public E get(int index) {
         //先check给出的索引值是否越界
        checkElementIndex(index);
        return node(index).item;
    }
    //node方法
     Node<E> node(int index) {
        //这里将整个链表分为左半枝和右半枝
        //（size >>1） = size/2：
        //查找左半枝
        if (index < (size >> 1)) {
            //从first先找
            Node<E> x = first;
            //从first查到index处
            for (int i = 0; i < index; i++)
                //用next不断查找第index处的元素
                x = x.next;
            return x;
        //查找右半枝
        } else {
            //从last先找
            Node<E> x = last;
            //从last查到index处
            for (int i = size - 1; i > index; i--)
             //用previous不断查找第index处的元素
                x = x.prev;
            return x;
        }
    }

接下来看看根据一个元素去Remove一个节点

 public boolean remove(Object o) {
    //如果移除空元素
        if (o == null) {
        //从firts一直查到last，因为last.next==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) {
        //先获取到要删除元素的三个属性
        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;
            //切断next锁链
            x.next = null;
        }
        //元素为null
        //这是整个Node才会被GC
        x.item = null;
        //长度减少1
        size--;
        //操作次数加1
        modCount++;
        return element;
    }

在继承抽象类AbstractSequentialList有根据index去remove一个一个节点。在AbstractSequentialList抽象类中基本上都是关于使用index去操作LinkedList。

在某一个位置set一个元素和删除其实道理一样，都是切断后重新在连接。