LinkedList源码解析之链表结构

1. 单链表与双链表的结构图 
    代码：

   // 单向链表 
   class Node<E> {
           E item;        // data元素
           Node<E> next;  // 下一个节点
           ......
    }
   
   // 双向链表 
   class Node<E> {
           E item;        // data元素
           Node<E> next;  // 下一个节点
           Node<E> prev;  // 上一个节点
           ......
    }

   
   LinkedList采用的是双向链表
2. LinkedList的add()方法

       public boolean add(E e) {
           linkLast(e);
           return true;
       }
   
   
        void linkLast(E e) {
           // 获取当前最后一个节点
           final Node<E> l = last;
           // 创建新的节点  l表示:上一个节点  e表示: 添加的元素  null表示: 下一个节点
           final Node<E> newNode = new Node<>(l, e, null);
           // 将新节点复制到last节点
           last = newNode;
           // 判断是否是最后一个节点
           if (l == null)
               first = newNode;  // 如果是第一个节点就赋值first节点
           else
               l.next = newNode; // 否则修改原来最后一个节点nexe为当前新增节点
           size++;
           modCount++;
       }

3. LinkedList的get()方法 

     public E get(int index) {
           // 检查是否越界
           checkElementIndex(index);
           return node(index).item;
       }
   
   
      Node<E> node(int index) {
            // 折半查找,  判断当前index与集合size的一半值比较   size >> 1 表示 size 除以 2
           if (index < (size >> 1)) {
               // true 从first节点开始往后查询，查询至index(不包括index)节点的next位置
               Node<E> x = first;
               for (int i = 0; i < index; i++)
                   x = x.next;
               return x;
           } else {
               // 否则从last节点开始往前查询， 查询至index(不包括index)节点的prev位置
               Node<E> x = last;
               for (int i = size - 1; i > index; i--)
                   x = x.prev;
               return x;
           }
       }

    LinkedList 采用折半查找，效率低
4. LinkedList的remove()方法 

       public E remove(int index) {
           // 检查是否越界
           checkElementIndex(index);
           return unlink(node(index));
       }
       
       
       // 通过折半查找获取当前删除的元素 
       Node<E> node(int index) {
   
           if (index < (size >> 1)) {
               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;
           }
       }
   
    E unlink(Node<E> x) {
           // 获取当前元素、和当前元素的first、next节点
           final E element = x.item;
           final Node<E> next = x.next;
           final Node<E> prev = x.prev;
           // 判断当前元素是否是一个节点
           if (prev == null) {
               first = next; // 将当前元素的next节点设置first节点
           } else {
               prev.next = next; // 将当前元素的next节点设置上一个节点的next节点
               x.prev = null;  // gc回收
           }
           // 判断当前元素是否是一个节点 ....
           if (next == null) {
               last = prev;  // 将当前元素的prev节点设置last节点
           } else {
               next.prev = prev;  // 将当前元素的prev节点设置下一个节点的prev节点
               x.next = null;
           }
   
           x.item = null;
           size--;
           modCount++;
           return element;
       }

     LinkedList的remove()主要是改变节点的next和prev指向