我的LinkedList源码理解

LinkedList源码理解

• 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 Node<E> first;
      //    尾节点
      transient Node<E> last;
  

• 获取节点

      //    获取首节点
      public E getFirst() {
          final Node<E> f = first;
          if (f == null)
              throw new NoSuchElementException();
          return f.item;
      }
      
      //    获取尾节点
       public E getLast() {
          final Node<E> l = last;
          if (l == null)
              throw new NoSuchElementException();
          return l.item;
      }
      
      //    获取指定下标的节点
      public E get(int index) {
          checkElementIndex(index);
          return node(index).item;
      }
  

• 修改节点

      public E set(int index, E element) {
          checkElementIndex(index);
          Node<E> x = node(index);
          E oldVal = x.item;
          x.item = element;
          return oldVal;
      }
  

• 添加节点

       /**
       * Links e as first element. 添加链表第一个节点
       */
      private void linkFirst(E e) {
      	//    将第一个节点赋值给 f
          final Node<E> f = first;
          //    创建一个节点                   开头 数据 结尾
          final Node<E> newNode = new Node<>(null, e, f);
          //    把节点赋值给 first
          first = newNode;
          //    如果 f  节点等于空
          if (f == null)
          	//    将节点赋值给最后
              last = newNode;
          else
          	//    将新建的节点等于fist节点的开头（连接）
              f.prev = newNode;
          size++;
          modCount++;
      }
  
      /**
       * Links e as last element. 添加链表最后一个元素
       */
      void linkLast(E e) {
      	//    将最后的节点 赋值给 l
          final Node<E> l = last;
          //    创建新的节点                  开头 数据 结尾
          final Node<E> newNode = new Node<>(l, e, null);
          //    将新节点赋值给 last
          last = newNode;
          //    如果 l 节点等于空
          if (l == null)
          	//    新节点 赋值给 first
              first = newNode;
          else
          	//    新节点的等于最后节点的结尾（连接）
              l.next = newNode;
          size++;
          modCount++;
      }
  
      //    连接到指定节点之前
      void linkBefore(E e, Node<E> succ) {
          // assert succ != null;
      	//    获取参数节点的上一个节点引用
          final Node<E> pred = succ.prev;
          //    创建新节点，
          final Node<E> newNode = new Node<>(pred, e, succ);
  		//    将下个节点的首节点指向当前节点
          succ.prev = newNode;
          if (pred == null)
              first = newNode;
          else
              pred.next = newNode;
          size++;
          modCount++;
      }
  

• 删除节点

      /** 删除节点（第一个）
       * Unlinks non-null first node f.
       */
      private E unlinkFirst(Node<E> f) {
          // 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;
      }
  
      /**删除节点（最后一个节点）
       * Unlinks non-null last node l.
       */
      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;
      }
  
      /**删除节点
       * Unlinks non-null node x.
       */
      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;
      }