JDK 1.8 HashMap 源码阅读二

HashMap中对key的hashcode再处理

由上篇文章我们已知HashMap的寻址是让key的hashcode与bucket长度取模。如果bucket长度为16，即只有hashcode的低四位参与了寻址。这大大加大的碰撞的发生。

HashMap中为了让碰撞几率减小，让hashcode更多位参与寻址。他做了如下处理：

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

即key的hashcode保留高16位，低16位的值为高16位与低16位的异或值。 这样处理，让hashcode的高16在bucket长度小的情况下也能参与寻址以减小碰撞的可能。

HashMap中Get方法的实现

其Get方法是通过Key值来获得对应的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) {
            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;
    }

由上诉代码我们可知：

-Get方法应用到了key的hashcode方法和equals方法。自定义类作为key时，需要实现这两方法。

-Get方法在取value后，并没有删除该键值对。即插入键值对，若无手动remove，可重复取用。
-Get方法并未过滤key为null的情况，同时也未应用到value的值。即支持key/value为null的情形。

HashMap中删除键值对

JDK中提供了2中删除方式：

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

以及

    @Override
    public boolean remove(Object key, Object value) {
        return removeNode(hash(key), key, value, true, true) != null;
    }

从中可以看出，不同处是方法一只对key做关键字删除，而方法二是同时推键值对做关键字删除。

但是其底层实现是同一函数的，只是参数不同而已。

    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;
    }

由上代码可知，其主要分为2个步骤，查找和删除。

其查找的实现就是Get方法的实现，而删除的操作就是从链表中摘除掉一个节点，或从红黑树中摘除一节点。

最后的说明

本人对HashMap的阅读并未深入到树形存储部分，因为红黑树的算法实现和结构是另一回事了，如要说明又是一篇很长的篇幅。

同时在阅读HashMap的源码时，我并未看到其有多线程的同步操作处理。即HashMap是非线程安全的。

需要线程安全，可以考虑HashTable和ConCurrentHashMap。