HashMap详解(二)

上一篇写到了HashMap的底层结构、构造函数、重要参数等

putVal()， put(K key, V value)

    //put一个键值对，底层其实走的是下面的putVal()方法
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //1.初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //2.bin为null，初始化第一个节点
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            //指定key的值已存在，那么记录下原先的值
            e = p;
        else if (p instanceof TreeNode)
            //红黑树
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //bin不为空，且与链表头不相同(==或equals)
            //3.
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //达到临界值转为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            //空实现，为LinkedHashMap预留
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //4.
    if (++size > threshold)
        resize();
    //空实现，为LinkedHashMap预留
    afterNodeInsertion(evict);
    return null;
}

源码看着累，这张图有助于我们理解(JDK1.8):

哈希算法

很多地方用到hash(key)
通过key得到hash值

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

key.hashCode()，通过key获取它的hashCode,比如
hashMap.put(“book”,3)
hashCode(“book”) = 3029732， 为什么是这数呢？参照这个:

//String类里面的计算hashCode方法:
//大体思路是每个字符乘以31的幂，再累加
    public int hashCode() {
        int h = hash;
        final int len = length();
        if (h == 0 && len > 0) {
            for (int i = 0; i < len; i++) {
                h = 31 * h + charAt(i);
            }
            hash = h;
        }
        return h;
    }

这里在原生hashCode的基础上做了一次与高16位相异或的处理，这样做的目的是将哈希值的高位纳入到取余运算中来，防止由于低位相同造成的频繁冲突的情况。

hash算法的容量为什么是2的幂次方:

hash(Key) & (Length-1)
Length为2的幂次方，则减一后为0111111…11，低位都是1。好处就很明显了，如果Length为10，与上很多种hashcode的值后得到的都是相同的值，即哈希碰撞



最后返回的Index的值相等的几率远比Lenght-1为1111大，反推就能明白为什么容量要是2的幂次方了。
下面拓展到了hashmap的线程安全，欢迎大佬们指导
HashMap详解(三)