1.     public boolean add(E e) {
    2.         linkLast(e);
    3.         return true;
    4.     }
    1.     void linkLast(E e) {
    2.         final Node<E> l = last;
    3.         final Node<E> newNode = new Node<>(l, e, null);
    4.         last = newNode;
    5.         if (l == null)
    6.             first = newNode;
    7.         else
    8.             l.next = newNode;
    9.         size++;
    10.         modCount++;
    11.     }
    1.     public void add(int index, E element) {
    2.         checkPositionIndex(index);
    4.         if (index == size)
    5.             linkLast(element);
    6.         else
    7.             linkBefore(element, node(index));
    8.     }
    1.     void linkBefore(E e, Node<E> succ) {
    2.         // assert succ != null;
    3.         final Node<E> pred = succ.prev;
    4.         // 初始化节点，并指明前驱和后继节点
    5.         final Node<E> newNode = new Node<>(pred, e, succ);
    6.         // 将succ节点前驱引用prev指向新节点
    7.         succ.prev = newNode;
    8.         // 判断尾节点是否为空，为空表示当前链表没有节点
    9.         if (pred == null)
    10.             first = newNode;
    11.         else
    12.             pred.next = newNode; // succ节点前驱的后继引用指向新节点
    13.         size++;
    14.         modCount++;
    15.     }

    LinkedList新增元素的逻辑流程
    （1）创建新节点，并指明新节点的前驱和后继
    （2）将succ的前驱引用指向新节点
    （3）如果succ的前驱不为空，则将succ前驱的后继引用指向新节点

    1.     public boolean addAll(int index, Collection<? extends E> c) {
    2.         checkPositionIndex(index);
    4.         Object[] a = c.toArray();
    5.         int numNew = a.length;
    6.         if (numNew == 0)
    7.             return false;
    9.         Node<E> pred, succ;
    10.         if (index == size) {
    11.             succ = null;
    12.             pred = last;
    13.         } else {
    14.             succ = node(index);
    15.             pred = succ.prev;
    16.         }
    18.         for (Object o : a) {
    19.             @SuppressWarnings("unchecked") E e = (E) o;   //注解抑制没有进行类型检查操作的警告
    20.             Node<E> newNode = new Node<>(pred, e, null);
    21.             //让前驱节点连接新节点  
    22.             if (pred == null)  //如果插入节点为第一个节点
    23.                 first = newNode;
    24.             else
    25.                 pred.next = newNode;
    26.             pred = newNode;
    27.         }
    28.         // 上面先将前驱与新节点连接 接下来 最后一个新节点连接后继节点（succ节点 或 last节点）
    29.         if (succ == null) {
    30.             last = pred;
    31.         } else {
    32.             pred.next = succ;
    33.             succ.prev = pred;
    34.         }
    36.         size += numNew;
    37.         modCount++;
    38.         return true;
    39.     }