HashMap解读（二）

上一篇我们研究完put()方法，这也让我们对HashMap的存储原理有了一些认识，我们接下来简单的看看其他常用方法。

get()方法

最常用的方法：通过key找到对应的value，有点映射的味道。

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

给个结点对象e，通过形参key去我的“仓库”里找，找到返回结点的value，没找到返回null；
关键在于怎么去“仓库”里找

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) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

我们需要做两件事：
1.想要去“仓库”找，那我们先拿到这个仓库，第一个if中：

(tab = table) != null

2.有了仓库，我们需要去找货架

(first = tab[(n - 1) & hash]) != nulld

我们可以回想下如何将一个数据存进这个仓库，就是我们前面说的putVal()方法
存储过程：tab[i = (n - 1) & hash]
原理：hashCode%(2的4次方-1)
现在我们看到了一个一样的东西，就是这个理。直接就拿到了key对应的链表或红黑树
剩下的就是便利链表或红黑树，这个就比较简单了。

remove()方法

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

我们发现，remove的结构和get非常相似

    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;
        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;
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

我们再次看到了 (n - 1) & hash
找仓库的货架，然后看看货架上的链表是不是我要删的key，找了key一会调用removeTreeNode（）方法将这个结点从树上移除。