final Node<K,V> removeNode(int hash, Object key, Object value,

                             boolean matchValue, boolean movable) {

     Node<K,V>[] tab; Node<K,V> p; int n, index;

     //如果HashMap未初始化或哈希值对应下标无节点，不需要执行移除操作

     if ((tab = table) != null && (n = tab.length) > 0 &&

         (p = tab[index = (n - 1) & hash]) != null) {

         Node<K,V> node = null, e; K k; V v;

         //头节点等于目标元素

         if (p.hash == hash &&

             ((k = p.key) == key || (key != null && key.equals(k))))

             node = p;

         else if ((e = p.next) != null) {

             //如果是树结构，调用红黑树的接口获取目标节点

             if (p instanceof TreeNode)

                 node = ((TreeNode<K,V>)p).getTreeNode(hash, key);

             else {

                 //链表结构，遍历整个链表

                 do {

                     if (e.hash == hash &&

                         ((k = e.key) == key ||

                             (key != null && key.equals(k)))) {

                         node = e;

                         break;

                     }

                     p = e;

                 } while ((e = e.next) != null);

             }

         }

         //如果移除前需要判断节点的值，则目标值与原值相等才能移除

         if (node != null && (!matchValue || (v = node.value) == value ||

                                 (value != null && value.equals(v)))) {

             //调用红黑树的接口移除树节点

             if (node instanceof TreeNode)

                 ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);

             //如果目标元素等于头节点的值，移除对头节点的引用，指向下一个节点

             else if (node == p)

                 tab[index] = node.next;

             //如果是链表结构，则前序节点的next指向要移除节点的下一个节点

             else

                 p.next = node.next;

             ++modCount;

             --size;

             afterNodeRemoval(node);

             return node;

         }

     }

     return null;

 }