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

LinkedList linkedList = new LinkedList<>();
linkedList.add("one");
linkedList.add("two");
linkedList.add(0, "yibu");
linkedList.get(1);
linkedList.push("four");

transient Node<E> last;
// LinkedList 只有两个构造函数,一个无参一个带参。无参构造函数内部没有任何内容
// 主要看 add() 后的代码
public boolean add(E e) {
    linkLast(e);
    return true;
}
// add() 内部调用了 linkLast(e)
/**
 * Links e as last element. 作为最后一个节点插入
 */
void linkLast(E e) {
    final Node<E> l = last; // 保存原先的最后一个节点。当我第一次 add 时, last 一开始为 null,第二次 add 时才有值
    final Node<E> newNode = new Node<>(l, e, null); // 通过这一步创建新节点并保存,Node 类在上方有贴出来过
                                                    // 其实就是把 e 变成链表节点给它添加前后引用
    last = newNode;                                 // last 始终是 add 进来的最新节点
    if (l == null)                                  // 这里也是判断如果是第一次 add,那么first 就是第一个节点
        first = newNode;                            
    else                                            // 不是第一次add的话,那么 l 对应原先最后一个节点,
        l.next = newNode;                           // 原先最后一个节点由指向null转为指向新节点了
    size++;                                         // 长度自增
    modCount++;                                     // 修改次数自增
}
// 接下来是第 add(int index, E element)
public void add(int index, E element) {             // 带索引的add
    checkPositionIndex(index);                      // 其实就是判断index是不是在链表容量内且大于0
    if (index == size)                              
        linkLast(element);                          // 索引正好==size,插到最后
    else
        linkBefore(element, node(index));           // 在本来已经互相引用的两节点中横插一脚,小三啊~~~
}
// 看看 linkBefore() 方法
/**
 * Inserts element e before non-null Node succ.
 */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;                 // 目前链表中对应索引的节点succ对前一个节点的引用succ.prev
    final Node<E> newNode = new Node<>(pred, e, succ); // 由于横插一脚,需要让新插入的节点e向后引用succ,
                                                    // 向前引用succ.prev。
                                                    // 注意,此时succ和succ.prev间的引用还未切断
    succ.prev = newNode;                            // 这一步改变succ的向前引用
    if (pred == null)
        first = newNode;                            // 如果原先succ向前引用的是null,那么插入的节点就是第一个节点
    else
        pred.next = newNode;                      // 这一步改变原先succ.prev的向后引用(其实已经不是succ.prev了)
    size++;
    modCount++;
}
// 接下来看看get()
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;                        // 主要通过node()来实现的  
}
// 看看 node()
Node<E> node(int index) {
    // assert isElementIndex(index);
    if (index < (size >> 1)) {              // 这一步先拿 index 和 size的一半作比较。
                                            // 这里依赖于 LinkedList 是有序的,
                                            // 不然不可能因为index与size的一半比较就能得出index大概在什么地方
        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;
    }
}
// 模拟堆栈主要用到 push 和 pop
// 刚开始没在意,以js的思维去想主观上认为 push 是放到最后一个节点上,但这和 add 不就重合了吗
// 看了下源码,貌似自己想错了,实践了下,果然, push 其实是放到第一个节点
// 又看了下 pop(),发现果然删的是向后引用,难怪叫后进先出呢
public void push(E e) {
    addFirst(e);
}
public void addFirst(E e) {
    linkFirst(e);
}
private void linkFirst(E e) {
    final Node<E> f = first;  // 套路啊,保存的是 first
    final Node<E> newNode = new Node<>(null, e, f); // 这里新增是新节点没有向前引用,倒是向后引用了原先的第一节点
    first = newNode;          // 到这里就该明白了,第一节点改朝换代了
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;     // 改变原第一节点的向前引用
    size++;
    modCount++;
}