HashMap源码解析《三》get,remove方法

1.hashmap中的get方法

   public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;     //根据得到结果取得值，如果不存在当前键则返回null,如果存在返回value值
    }

 final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) { //判断执行条件，数组初始划过并且长度大于0，并且当前hash对应的桶元素不为空
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;      //如果桶元素的hash值与当前hash相同，则返回当前桶元素
            if ((e = first.next) != null) {  //如果不是，且存在链表或者红黑树中存在数据，将桶元素执行的Node赋值给e
                if (first instanceof TreeNode)   //红黑树  红黑树查询
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&   //遍历寻找hash值相等，并且键值相等的Node并且返回
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;  //如果没有找到 则返回null;
    }

get方法总的来说没有put方法那么复杂，他不需要牵扯太多的数组变化，也无需在意是否到达阈值。只需要在寻找的时候，判断数组是否被初始化过，数组长度中是否有元素，并且当前的hash值在数组中存在下标索引，那么只需比对对应的Node，遍历整个链表，寻找hash值相等，并且键值相等的node，如果没有找到，则返回null.

与之相关的函数还有contiansKey方法；

    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;    //如果存在，则返回Node值， 返回值为true;
    }

2,hashMap的remove方法

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;  //remove方法，如果找到那个Node,移除并且返回，如果没找到，返回null;
    }

 final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {

// matchValue 作用：区别remove(Key key)与remove(Key key,Value value) 如果matchValue为false,删除key相等的节点。
//如果为true则删除使需要key和value都相等
//movable 表示再删除节点的时候是否改变树的结构。如果为false，在删除的时候不移动，一般都为true只有在iterator的时候才为false;

     

  Node<K,V>[] tab; Node<K,V> p; int n, index; 
        if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {
                //判断数组是否初始化，是否存在元素，当前hash下标是否存在值； 
            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;      //判断根节点是否是需要删除的节点，如果是赋值给node 
            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; //如果找到 给node赋值 
                        break; 
                        }    
                     p = e; //否则继续遍历,但是保存当前值。p就是需要删除节点的前驱节点
                    } while ((e = e.next) != null); 
                }
            }
            //判断是否已经找到node ，是否需要比较value
           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; 
                    else //表示需要删除的点是在链表中 
                           p.next = node.next; //让前驱节点越过当前节点，指向下一节点；
                      ++modCount; //修改次数增加 
                      --size; 
                      afterNodeRem oval(node); 
                      return node; 
                    } 
                   } 
            return null; 
        }