提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档


文章目录

  • 一、什么是哈希冲突
  • 二、如何解决哈希冲突


一、什么是哈希冲突

当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。
哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。

二、如何解决哈希冲突

哈希冲突的解决方案有多种:开放地址法（发生冲突，继续寻找下一块未被占用的存储地址），二次散列函数法，链地址法。

在HashMap中就用到了二次散列的方法：

final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {//这里针对String优化了Hash函数，是否使用新的Hash函数和Hash因子有关  
            return sun.misc.Hashing.stringHash32((String) k);
        }
		//二次散列，没有直接用hashCode的值，解决hash冲突
        h ^= k.hashCode();
        
		//扰动函数，增加值的不确定性
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

还有链地址法数组+链表的方式
什么是链地址法，简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么对于查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。
HashMap做了一个Entry数组：

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;  // 键
    V value;  // 值
    Entry<K,V> next; // 指向下一个节点 ，也是一个Entry对象，从而形成解决hash冲突的单链表
    int hash;  // hash值
  
    /** 
     * 构造方法，创建一个Entry 
     * 参数：哈希值h，键值k，值v、下一个节点n 
     */  
    Entry(int h, K k, V v, Entry<K,V> n) {  
        value = v;  
        next = n;  
        key = k;  
        hash = h;  
    }  
  
    // 返回 与 此项 对应的键
    public final K getKey() {  
        return key;  
    }  

    // 返回 与 此项 对应的值
    public final V getValue() {  
        return value;  
    }  
  
    public final V setValue(V newValue) {  
        V oldValue = value;  
        value = newValue;  
        return oldValue;  
    }  
    
   /** 
     * equals（）
     * 作用：判断2个Entry是否相等，必须key和value都相等，才返回true  
     */ 
      public final boolean equals(Object o) {  
        if (!(o instanceof Map.Entry))  
            return false;  
        Map.Entry e = (Map.Entry)o;  
        Object k1 = getKey();  
        Object k2 = e.getKey();  
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {  
            Object v1 = getValue();  
            Object v2 = e.getValue();  
            if (v1 == v2 || (v1 != null && v1.equals(v2)))  
                return true;  
        }  
        return false;  
    }

在put()方法中处理哈希冲突：

public V put(K key, V value) {
        //如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），
        //入参为threshold，此时threshold为initialCapacity 默认是1<<4(=16)
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);//分配数组空间
        }
       	//对空值进行判断---允许空值null
        if (key == null)
            return putForNullKey(value);
        //获取哈希码
        int hash = hash(key);
        //得到对应数组下标位置
        int i = indexFor(hash, table.length);
        //如果放入的数组的位置上没有元素，那么直接添加，不用走这个for循环
        //e ！= null 满足的话就证明这个位置上有东西了
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //发生哈希冲突的时候，会先比较哈希值
            //比较是否是同一个对象，equals就不比
            //如果不是同一个对象，会比较equals方法
            //如果哈希值一样，equals方法的结果也一样，那么才会走这个if方法
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            	//获取老的value
                V oldValue = e.value;
                //新value替换老value----只替换value 不替换key
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        //新增一个entry
        addEntry(hash, key, value, i);
        return null;
    }