HashMap源码阅读（2）- 碰撞（冲突）与扩容

最新推荐文章于 2022-10-15 23:45:39 发布

置顶 vicklin

最新推荐文章于 2022-10-15 23:45:39 发布

阅读量1.1k

点赞数 1

分类专栏： web HashMap 文章标签： HashMap 冲突碰撞扩容

本文链接：https://blog.csdn.net/vicklin/article/details/44776199

版权

web 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

HashMap

2 篇文章 0 订阅

订阅专栏

本文深入探讨HashMap中的hash碰撞问题，包括开放地址法、再哈希法和内链法（以链表形式处理碰撞）。此外，文章还分析了HashMap的扩容机制，当元素数量达到阈值时，HashMap会进行1倍扩容。通过理解这些原理，有助于更好地掌握HashMap的内部工作方式。

摘要由CSDN通过智能技术生成

上次在 HashMap源码阅读（1）- 初始值、数据结构、hash计算一文中描述了hashMap的初始大小，底层存储结构，以及哈希值计算和index计算，本文将接着上文，继续深入了解HashMap中hash碰撞和扩容问题

1）hash碰撞

谈hash，不得不提的当然是hash碰撞的问题，所谓hash碰撞，简单地说即由不同的key所计算出相同的hash值。笔者才疏学浅，所掌握的解决hash碰撞的方式有以下几种：

1.开放地址法：

当冲突发生时，使用某种探查(亦称探测)技术在散列表中形成一个探查(测)序列。沿此序列逐个单元地查找，直到找到给定的关键字，或者碰到一个开放的地址(即该地址单元为空)为止（若要插入，在探查到开放的地址，则可将待插入的新结点存人该地址单元）。查找时探查到开放的地址则表明表中无待查的关键字，即查找失败。开放地址法有几种处理方式，在此不细谈，读者可自行谷歌百度。

2.再哈希法：

这种方法是同时构造多个不同的哈希函数：

Hi=RH1（key） i=1，2，…，k

当哈希地址Hi=RH1（key）发生冲突时，再计算Hi=RH2（key）……，直到冲突不再产生。这种方法不易产生聚集，但增加了计算时间。

3.内链法：

此方法的基本思路是：当发生hash碰撞时，在碰撞处建立链表，将碰撞的所有值以链表的形式维护起来。如下图：

在HashMap的代码中，hash碰撞问题又是如何解决的呢？我们来看下HashMap的put函数：

 public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold); // 此为前文所提到的inflateTable函数，用于初始化table，并将capacity提至2的n次幂
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key); // 位运算hash值
        int i = indexFor(hash, table.length);  // return hash & (table.length-1)
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // for循环中寻找如果发现是同一元素，则更新其值
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
 
        // 不存在同值，往下走，将key、value、hash以及index（i）创建为Entry并存储到table数组中
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }
 
 
    /**
     * 将key、value、hash以及index构建entry并存于table数组中
     */
    void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) { // 判断当前容量是否超过阀值&&该table位置是否有值
            resize(2 * table.length); // 如果达到阀值，则扩容1倍
            hash = (null != key) ? hash(key) : 0; // 扩容后重新计算hash值
            bucketIndex = indexFor(hash, table.length); // 扩容后重新计算索引下标
        }
 
        createEntry(hash, key, value, bucketIndex); // 将entry创建并存于table
    }
 
    /**
     * 创建entry，存于table数组中
     */
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex]; // 获取table当前该位置的值（用于处理碰撞，建立内链）
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        size++;
    }
 
     /**
      * 以链表的方式创建entry，内链到上个值.
      */
     Entry(int h, K k, V v, Entry<K,V> n) {
          value = v;
          next = n;
          key = k;
          hash = h;
      }

由代码和注释可知，当HashMap发生碰撞的时候，首先获取当前存在的值e，然后将e作为新创建的Entry的next值，并将新创建的Entry值至于table中，也就是说，假设hash函数为（k%5）,存在21和36两个数，其散列结果都是1，则首先Entry(21)会被存于table[1]的位置中，然后当36被put到HashMap中时，Entry(36)会被放到table[1]中，而21则是:Entry(36).next=Entry(21).

2）扩容:

之前的文章中我们提到DEFAULT_LOAD_FACTOR，从前文的种种描述中，相信读者也明白此参数用于计算HashMap扩容的阀值threshold，即threshold=capacity*DEFAULT_LOAD_FACTOR; 当HashMap中的size到达threshold的时候，HashMap会对自身进行1倍扩容（为何一倍，前文已描述）。

HashMap的resize函数很简单：

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
 
        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

创建一个新的，一倍大小的table数组，然后将旧的table数组全部移到新的table数组中。但是，关键问题在transfer函数中。试想一下，我们前面所谈到的index值是根据HashMap中的table.length计算的，如今table的大小增加了一倍，index的结果自然就需要重新计算，所以，在transfer函数中：

/**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            // 处理碰撞的链表
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity); // 重新计算index
                e.next = newTable[i]; // 链式
                newTable[i] = e;
                e = next;
            }
        }
    }

至此，HashMap的基本原理得到一定的梳理，下次希望能对concurrentHashMap进行源码分析。

本文连接：HashMap源码阅读（2）- 碰撞与扩容

本文作者：vick

转载请注明：http://www.iyowei.cn/2015/03/hashmap-collision-resize/