HashMap如何求哈希值？

相关源码，首先看put源码：

put源码：

public V put(K key, V value) {    
     return putVal(hash(key), key, value, false, true);
}

put方法内部调用putVal（）方法，还调用了hash（）方法。hash（）方法通过hash函数计算key对应的哈希值。

hash函数源码如下：

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

如果key为null，返回0，不为null，则通过(h = key.hashCode()) ^ (h >>> 16)公式计算得到哈希值。

该公式通过hashCode的高16位异或低16位得到哈希值，主要从性能、哈希碰撞角度考虑，减少系统开销，不会造成因为高位没有参与下标计算从而引起的碰撞。

key不为0的例子：

1.假设key调用hashCode()方法,key.hashCode()为：1111 1111 1111 1111 1111 0000 1100 0001

2.右移16位后的值（h >>> 16）：0000 0000 0000 0000 1111 1111 1111 1111

3.(h = key.hashCode()) ^ (h >>> 16)，得到哈希值。（^(异或运算):相同的二进制数位上，数字相同则为0，不同则为1）：
1111 1111 1111 1111 0000 1111 0011 1110

4.(n-1) & hash计算key在数组中的存放索引。n为数组长度，初始化数组长度为16。（&(与运算):相同的二进制数位上，都为1才是1，否则都是0）：
0000 0000 0000 0000 0000 0000 0000 1111

得到key对应的哈希值后，再调用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;     

   // 如果数组(哈希表)为null或者长度为0，则进行数组初始化操作    
   if ((tab = table) == null || (n = tab.length) == 0)        
   n = (tab = resize()).length;  
    
   // 根据key的哈希值计算出数据插入数组的下标位置，公式为(n-1)&hash，数组长度为16为例，(n1)&hash得到的值都小于16    
   if ((p = tab[i = (n - 1) & hash]) == null)        
   // 如果该下标位置还没有元素，则直接创建Node对象，并插入        
         tab[i] = newNode(hash, key, value, null);   
         else {        
         Node<K,V> e; K k;        
   // 如果目标位置key已经存在，则直接覆盖          
        if (p.hash == hash &&           
        ((k = p.key) == key || (key != null && key.equals(k))))            
        e = p;       
    // 如果目标位置key不存在，并且节点为红黑树，则插入红黑树中        
       else if (p instanceof TreeNode)            
       e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);        
       else {            
    // 否则为链表结构，遍历链表，尾部插入            
      for (int binCount = 0; ; ++binCount) {                
      if ((e = p.next) == null) {                    
      p.next = newNode(hash, key, value, null);                    
    // 如果链表长度大于等于TREEIFY_THRESHOLD，则考虑转换为红黑树                    if (binCount >= TREEIFY_THRESHOLD - 1)
     // -1 for 1st                        
     treeifyBin(tab, hash); 
     // 转换为红黑树操作，内部还会判断数组长度是否小于MIN_TREEIFY_CAPACITY，如果是的话不转换                    
     break;               }                
     // 如果链表中已经存在该key的话，直接覆盖替换                
     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;            
      afterNodeAccess(e);           
      return oldValue;       
      }   
  }    
  
     // 模数递增    ++modCount;    
     // 当键值对个数大于等于扩容阈值的时候，进行扩容操作    
     if (++size > threshold)        resize();    
     afterNodeInsertion(evict);    
     return null;
 }

put操作过程总结：

1.判断HashMap数组是否为空，是的话初始化数组（由此可见，在创建HashMap对象的时候并不会直接初始化数组）；

2.通过(n-1) & hash计算key在数组中的存放索引；

3.目标索引位置为空的话，直接创建Node存储；

4.目标索引位置不为空的话，分下面三种情况：
4.1. key相同，覆盖旧值；
4.2. 该节点类型是红黑树的话，执行红黑树插入操作；
4.3. 该节点类型是链表的话，遍历到最后一个元素尾插入，如果期间有遇到key相同的，则直接覆盖。
如果链表长度大于等于TREEIFY_THRESHOLD，并且数组容量大于等于MIN_TREEIFY_CAPACITY，则将链表转换为红黑树结构；（即链表长度大于8，且数组容量大于等于64，链表转化为红黑树）

5.判断HashMap元素个数是否大于等于threshold，是的话，进行扩容操作。
（即超过扩容阀值，就重新创建一个指定容量的数组，然后将旧值复制到新的数组里。扩容阀值=加载因子*数组容量，加载因子=0.75）