HashMap学习笔记（二）put()，hash()，putVal()方法

put()，hash()

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
   // hash方法：key的散列值与key的高16位（>>>16）按位异或（^），获得hash值
}

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

hash函数的作用

​ hash函数起到"扰动"作用，当 key 不为空时，获取到的 hashCode 值为 int 类型，32位。在 putVal 函数中通过与数组最大下标 -1 按位与，得到当前 KV 在数组中的下标。

例：当 hashMap 数组大小为16时
hash() : 1111 1010 0101 1101 1111 0000 1010 1011
(n-1) & hash : 1111 1010 0101 1101 1111 0000 1010 1011
 	       &   0000 0000 0000 0000 0000 0000 0000 1111
 	       ————————————————————————————————————————————
 	       	   0000 0000 0000 0000 0000 0000 0000 1011
  按位与，数组下标(n-1)高位全为0，导致hash值高位对于下标的结果没什么影响

int 类型范围从**-2147483648到2147483648**，一个有 40 亿个元素的数组，内存是放不下的。

由例子可见高位的值对计算下标的结果没什么影响，那么即使散列值再松散，当前也只有低位的几个数对下标有影响，可能导致哈希碰撞比较严重。为了让高位的值对计算下标的结果造成一定影响，hash 函数在得出 key 的散列值后与散列值的高 16 位进行了按位异或运算

例:
hashCode: 1010 1111 0101 1001 0110 1101 1010 1110
>>> 16  : 0000 0000 0000 0000 1010 1111 0101 1001
^  	    : 0000 0000 0000 0000 0010 1101 0000 1000
(n-1) & hash : 0000 0000 0000 0000 0000 0000 0000 1000

这样做，同时保存高位和低位的信息，使得下标哈希碰撞的可能减小，增加了随机性

putVal()

/**
 * Implements Map.put and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        //如果哈希桶为空，则初始化数组（按需创建）  resize：创建数组或者二倍扩容数组 (<< 1)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null) 
        //hash 值与数组游标最大值按位与，得出节点在数组中存储的位置，如果该位置没有数据，则将节点插入哈希桶（头插）
        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))))
            e = p;
        //判断当前位置的key值与该节点key值是否相同
        else if (p instanceof TreeNode)
            //判断在数组中当前位置的节点是否是树节点（数组+链表 / 数组+红黑树），如果是树节点，则调用putTreeVal插入节点
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //数组中当前位置节点不是树节点，说明是链表；遍历链表，如果链表中没有相同key值，则将该节点插入至链表尾节点
            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
                        //将新节点插入至链表尾后，判断插入节点后的链表长度是否大于TREEIFY_THREHLOD （阈值），如果大于则调用 treeifyBin 方法，判断当前哈希桶长度是否大于 MIN_TREEIFY_CAPACITY (最小树化容量 = 64)，如果大于则将链表转换为红黑树，如果小于则将哈希桶扩容至64(resize() 会将数组内所有节点 rehash) 
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
       //如果e 为null ，则遍历或查找过程中key没有重复  
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            //hashMap 中此方法为空，在继承hashMap的子类（eg: LinkedHashMap）中具体实现了after...方法。
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //hashMap结构被修改次数
    ++modCount;
    if (++size > threshold)
        resize(); 
    afterNodeInsertion(evict);
    return null;
}