HashMap源码阅读(2)- 碰撞(冲突)与扩容

上次在 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/

时间: 2024-11-06 03:35:01

HashMap源码阅读(2)- 碰撞(冲突)与扩容的相关文章

HashMap源码阅读(1)- 初始值、数据结构、hash计算

最近有被问及HashMap的相关问题,不得不再阅读源码,刨根问底. 1)初始值 我们平常使用Map的时候,创建的时候都是Map<String,Object> map = new HashMap<String,Object>();那么HashMap的默认大小是多少呢?查看源码,发现这么一段: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /** * The default initial capacity - MUST be a power of

HashMap 源码阅读

目录 HashMap 源码阅读 Map 接口 数据结构 initialCapacity 和 loadFactor hash() 方法 resize() 查找 getNode() 方法 遍历 fast-fail 和 modCount 新增和更新 putVal() 方法 putMapEntries() 方法 删除 removeNode() 方法 总结 HashMap 源码阅读 之前读过一些类的源码,近来发现都忘了,再读一遍整理记录一下.这次读的是 JDK 11 的代码,贴上来的源码会去掉大部分的注释

Java Jdk1.8 HashMap源码阅读笔记二

三.源码阅读 3.元素包含containsKey(Object key) /** * Returns <tt>true</tt> if this map contains a mapping for the * specified key. * * @param key The key whose presence in this map is to be tested * @return <tt>true</tt> if this map contains

Java Jdk1.8 HashMap源码阅读笔记一

最近在工作用到Map等一系列的集合,于是,想仔细看一下其具体实现. 一.结构 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable 1.抽象类AbstractMap public abstract class AbstractMap<K,V> implements Map<K,V> 该类实现了Map接口,具体结

HashMap源码阅读

本文内容来自于HashMap的源码内容,作为学习的记录. HashMap是一种存储key-value对的对象.每个map不能包含重复的key,每个key至多映射一个value.我们可以看到HashMap实现自Map接口,继承自AbstractMap类. public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { //HashMap的默认

HashMap源码阅读分析(JDK1.8)

HashMap是JDK提供的经典容器之一,最近刚好时间充裕,于是自己看了一遍hashMap的源码实现,不同版本的JDK,HashMap的实现方式有所不同,本文主要针对JDK1.8的源码进行分析,至于各版本实现方式的不同,本文不做讨论,下面直接开始. 一.hash函数分析 map的put方法,首先调用的就是hash函数,返回key的hash值,其函数方法如下: static final int hash(Object key) { int h; return (key == null) ? 0 :

HashMap源码阅读笔记——常量与构造方法

DEFAULT_INITIAL_CAPACITY = 16 Node数组的默认长度 MAXIMUM_CAPACITY = 1073741824 Node数组的最大长度 DEFAULT_LOAD_FACTOR = 0.75F 负载因子,调控控件与冲突率的因数 TREEIFY_THRESHOLD = 8 链表转换为树的阈值,超过这个长度的链表会被转换为红黑树 UNTREEIFY_THRESHOLD = 6 当进行resize操作时,小于这个长度的树会被转换为链表 MIN_TREEIFY_CAPACI

HashMap源码阅读笔记——HashMap的实现原理浅析

在java8发布以前,HashMap的实现简单来说就是一个Node数组,通过hash算法尽可能的分散了元素的位置,当一个位置有超过一个元素时,用链表的形式将元素进行连接.在java8中HashMap的实现形式有了一些改动,其中比较重要的一点就是链表的阈值,当链表的长度大于等于7时,会将这个位置的链表转换为红黑树的形式,如下图. 在来说说hash算法,HashMap中使用的算法如下 static final int hash(Object key) { int h; return (key ==

jdk源码阅读-HashMap

前置阅读: jdk源码阅读-Map : http://www.cnblogs.com/ccode/p/4645683.html 在前置阅读的文章里,已经提到HashMap是基于Hash表实现的,所以在讲解HashMap之前 ,有必要提前了解下Hash的原理. 参考<算法导论><算法>