跟踪LinkedList源码，通过分析双向链表实现原理，自定义一个双向链表

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

    // 链表的所含元素个数
    transient int size = 0;

    // 链表的头节点
    transient Node<E> first;
    // 链表的尾节点
    transient Node<E> last;
    /*
     * 此属性在本类中没有，此属性是从父类AbstractSequentialList中继承而来
     * 链表结构被修改的次数，防止在迭代遍历过程中，修改链表结构
     */
    protected    int modCount = 0;

    public LinkedList() { } //头尾节点都是null的空链表

    //初始化后，包含集合c所有元素的链表
    public LinkedList(Collection<? extends E> c) { 
        this();
        addAll(c);//添加集合c所有元素
    }

    public boolean add(E e) {
        linkLast(e);//在尾部链接一个新元素
        return true;
    }

   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++;//添加一个元素，链表结构被修改一次，modCount自加一
    }

    public void add(int index, E element) {
        checkPositionIndex(index); //检查下标是否合法

        if (index == size)  //插入的位置index=size即可直接在链表尾部添加元素
            linkLast(element);
        else
            //在指定的节点之前插入元素
            linkBefore(element, node(index));
    }

    Node<E> node(int index) {
        //index作为循环遍历停止的条件
        if (index < (size >> 1)) { // 如果index小于size的一半，则从头部开始向后查找
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next; //将当前节点的后继节点赋值给当前节点
            return x;
        } else {     // 如果index大于size的一半，则从尾部开始向前查找
            Node<E> x = last;
            for (int i = size - 1; i > index; i--) 
                x = x.prev;//将当前节点的前驱节点赋值给当前节点
            return x;
        }
    }

    void linkBefore(E e, Node<E> succ) {
         //插入点节点succ的前驱节点pred
        final Node<E> pred = succ.prev;
        /*
         * 待插入的节点，
         * 此节点将取代插入点节点succ，插入点succ将后移一位
         * 此节点的前驱是插入点节点的前驱节点pred，其后继节点就是插入点节点succ
         */
        final Node<E> newNode = new Node<>(pred, e, succ);
        //插入点节点的前驱是待插入节点
        succ.prev = newNode;
        
        if (pred == null)
            /*
             * 插入点节点的前驱节点pred为为空，表明此时在头部直接插入节点
             * 那么链表更新后，当前的待插入节点就是头节点
             */
            first = newNode;
        else
            /*
             * 插入点节点的前驱节点pred的后继节点是待插入节点
             */
            pred.next = newNode;
        size++;
        modCount++;
    }