面经手册 · 第2篇《数据结构，HashCode为何使用31做为乘数？》

做者：小傅哥
博客：https://bugstack.cn

沉淀、分享、成长，让本身和他人都能有所收获！😄

1、前言

在面经手册的前两篇介绍了[《面试官都问我啥》]()和[《认知本身的技术栈盲区》]()，这两篇内容主要为了说明面试过程的考查范围，包括我的的自我介绍、技术栈积累、项目经验等，以及在技术栈盲区篇章中介绍了一个整套技术栈在系统架构用的应用，以此全方面的扫描本身有哪些盲区还须要补充。而接下来的章节会以各个系列的技术栈中遇到的面试题做为切入点，讲解技术要点，了解技术原理，包括；数据结构、数据算法、技术栈、框架等进行逐步展开学习。

在进入数据结构章节讲解以前能够先了解下，数据结构都有哪些，基本能够包括；数组(Array)、栈(Stack)、队列(Queue)、链表(LinkList)、树(Tree)、散列表(Hash)、堆(Heap)、图(Graph)。

而本文主要讲解的就是与散列表相关的HashCode，原本想先讲HashMap，但随着整理资料发现与HashMap的实现中，HashCode的散列占了很重要的一设计思路，因此最好把这部分知识补全，再往下讲解。

2、面试题

说到HashCode的面试题，可能这是一个很是核心的了。其余考点；怎么实现散列、计算逻辑等，均可以经过这道题的学习了解相关知识。

Why does Java's hashCode() in String use 31 as a multiplier?

这个问题其实☞指的就是，hashCode的计算逻辑中，为何是31做为乘数。

3、资源下载

本文讲解的过程当中涉及部分源码等资源，能够经过关注公众号：bugstack虫洞栈，回复下载进行获取{回复下载后打开得到的连接，找到编号ID：19}，包括；

1. HashCode 源码测试验证工程，interview-03
2. 103976个英语单词库.txt，验证HashCode值
3. HashCode散列分布.xlsx，散列和碰撞图表

4、源码讲解

1. 固定乘积31在这用到了

// 获取hashCode "abc".hashCode();
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

在获取hashCode的源码中能够看到，有一个固定值31，在for循环每次执行时进行乘积计算，循环后的公式以下；
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

那么这里为何选择31做为乘积值呢？

2. 来自stackoverflow的回答

在stackoverflow关于为何选择31做为固定乘积值，有一篇讨论文章，Why does Java's hashCode() in String use 31 as a multiplier? 这是一个时间比较久的问题了，摘取两个回答点赞最多的；

413个赞👍的回答

最多的这个回答是来自《Effective Java》的内容；

The value 31 was chosen because it is an odd prime. If it were even and the multiplication overflowed, information would be lost, as multiplication by 2 is equivalent to shifting. The advantage of using a prime is less clear, but it is traditional. A nice property of 31 is that the multiplication can be replaced by a shift and a subtraction for better performance: 31 * i == (i << 5) - i. Modern VMs do this sort of optimization automatically.

这段内容主要阐述的观点包括；

1. 31 是一个奇质数，若是选择偶数会致使乘积运算时数据溢出。
2. 另外在二进制中，2个5次方是32，那么也就是 31 * i == (i << 5) - i。这主要是说乘积运算可使用位移提高性能，同时目前的JVM虚拟机也会自动支持此类的优化。

80个赞👍的回答

As Goodrich and Tamassia point out, If you take over 50,000 English words (formed as the union of the word lists provided in two variants of Unix), using the constants 31, 33, 37, 39, and 41 will produce less than 7 collisions in each case. Knowing this, it should come as no surprise that many Java implementations choose one of these constants.

• 这个回答就颇有实战意义了，告诉你用超过5千个单词计算hashCode，这个hashCode的运算使用3一、3三、3七、39和41做为乘积，获得的碰撞结果，31被使用就很正常了。
• 他这句话就就能够做为咱们实践的指向了。

3. Hash值碰撞几率统计

接下来要作的事情并不难，只是根据stackoverflow的回答，统计出不一样的乘积数对10万个单词的hash计算结果。10个单词表已提供，能够经过关注公众号：bugstack虫洞栈进行下载

3.1 读取单词字典表

1    a    "n.(A)As 或 A's  安(ampere(a) art.一;n.字母A /[军] Analog.Digital,模拟/数字 /(=account of) 账上"
2    aaal    American Academy of Arts and Letters 美国艺术和文学学会
3    aachen     亚琛[德意志联邦共和国西部城市]
4    aacs    Airways and Air Communications Service (美国)航路与航空通信联络处
5    aah    " [军]Armored Artillery Howitzer,装甲榴弹炮;[军]Advanced Attack Helicopter,先进攻击直升机"
6    aal    "ATM Adaptation Layer,ATM适应层"
7    aapamoor    "n.[生]丘泽,高低位镶嵌沼泽"

• 单词表的文件格式如上，能够自行解析
• 读取文件的代码比较简单，这里不展现了，能够经过资源下载进行获取

3.2 Hash计算函数

public static Integer hashCode(String str, Integer multiplier) {
    int hash = 0;
    for (int i = 0; i < str.length(); i++) {
        hash = multiplier * hash + str.charAt(i);
    }
    return hash;
}

• 这个过程比较简单，与原hash函数对比只是替换了可变参数，用于咱们统计不一样乘积数的计算结果。

3.3 Hash碰撞几率计算

想计算碰撞很简单，也就是计算那些出现相同哈希值的数量，计算出碰撞总量便可。这里的实现方式有不少，可使用set、map也可使用java8的stream流统计distinct。

private static RateInfo hashCollisionRate(Integer multiplier, List<Integer> hashCodeList) {
    int maxHash = hashCodeList.stream().max(Integer::compareTo).get();
    int minHash = hashCodeList.stream().min(Integer::compareTo).get();
    int collisionCount = (int) (hashCodeList.size() - hashCodeList.stream().distinct().count());
    double collisionRate = (collisionCount * 1.0) / hashCodeList.size();
    return new RateInfo(maxHash, minHash, multiplier, collisionCount, collisionRate);
}

• 这里记录了最大hash和最小hash值，以及最终返回碰撞数量的统计结果。

3.4 单元测试

@Before
public void before() {
    "abc".hashCode();
    // 读取文件，103976个英语单词库.txt
    words = FileUtil.readWordList("E:/itstack/git/github.com/interview/interview-01/103976个英语单词库.txt");
}

@Test
public void test_collisionRate() {
    List<RateInfo> rateInfoList = HashCode.collisionRateList(words, 2, 3, 5, 7, 17, 31, 32, 33, 39, 41, 199);
    for (RateInfo rate : rateInfoList) {
        System.out.println(String.format("乘数 = %4d, 最小Hash = %11d, 最大Hash = %10d, 碰撞数量 =%6d, 碰撞几率 = %.4f%%", rate.getMultiplier(), rate.getMinHash(), rate.getMaxHash(), rate.getCollisionCount(), rate.getCollisionRate() * 100));
    }
}

• 以上先设定读取英文单词表中的10个单词，以后作hash计算。
• 在hash计算中把单词表传递进去，同时还有乘积数；2, 3, 5, 7, 17, 31, 32, 33, 39, 41, 199，最终返回一个list结果并输出。
• 这里主要验证同一批单词，对于不一样乘积数会有怎么样的hash碰撞结果。

测试结果

单词数量：103976
乘数 =    2, 最小Hash =          97, 最大Hash = 1842581979, 碰撞数量 = 60382, 碰撞几率 = 58.0730%
乘数 =    3, 最小Hash = -2147308825, 最大Hash = 2146995420, 碰撞数量 = 24300, 碰撞几率 = 23.3708%
乘数 =    5, 最小Hash = -2147091606, 最大Hash = 2147227581, 碰撞数量 =  7994, 碰撞几率 = 7.6883%
乘数 =    7, 最小Hash = -2147431389, 最大Hash = 2147226363, 碰撞数量 =  3826, 碰撞几率 = 3.6797%
乘数 =   17, 最小Hash = -2147238638, 最大Hash = 2147101452, 碰撞数量 =   576, 碰撞几率 = 0.5540%
乘数 =   31, 最小Hash = -2147461248, 最大Hash = 2147444544, 碰撞数量 =     2, 碰撞几率 = 0.0019%
乘数 =   32, 最小Hash = -2007883634, 最大Hash = 2074238226, 碰撞数量 = 34947, 碰撞几率 = 33.6106%
乘数 =   33, 最小Hash = -2147469046, 最大Hash = 2147378587, 碰撞数量 =     1, 碰撞几率 = 0.0010%
乘数 =   39, 最小Hash = -2147463635, 最大Hash = 2147443239, 碰撞数量 =     0, 碰撞几率 = 0.0000%
乘数 =   41, 最小Hash = -2147423916, 最大Hash = 2147441721, 碰撞数量 =     1, 碰撞几率 = 0.0010%
乘数 =  199, 最小Hash = -2147459902, 最大Hash = 2147480320, 碰撞数量 =     0, 碰撞几率 = 0.0000%

Process finished with exit code 0

以上就是不一样的乘数下的hash碰撞结果图标展现，从这里能够看出以下信息；

1. 乘数是2时，hash的取值范围比较小，基本是堆积到一个范围内了，后面内容会看到这块的展现。
2. 乘数是三、五、七、17等，都有较大的碰撞几率
3. 乘数是31的时候，碰撞的几率已经很小了，基本稳定。
4. 顺着往下看，你会发现199的碰撞几率更小，这就至关于一排奇数的茅坑量多，天然会减小碰撞。但这个范围值已经远超过int的取值范围了，若是用此数做为乘数，又返回int值，就会丢失数据信息。

4. Hash值散列分布

除了以上看到哈希值在不一样乘数的一个碰撞几率后，关于散列表也就是hash，还有一个很是重要的点，那就是要尽量的让数据散列分布。只有这样才能减小hash碰撞次数，也就是后面章节要讲到的hashMap源码。

那么怎么看散列分布呢？若是咱们能把10万个hash值铺到图表上，造成的一张图，就能够看出整个散列分布。可是这样的图会比较大，当咱们缩小看后，就成一个了大黑点。因此这里咱们采起分段统计，把2 ^ 32方分64个格子进行存放，每一个格子都会有对应的数量的hash值，最终把这些数据展现在图表上。

4.1 哈希值分段存放

public static Map<Integer, Integer> hashArea(List<Integer> hashCodeList) {
    Map<Integer, Integer> statistics = new LinkedHashMap<>();
    int start = 0;
    for (long i = 0x80000000; i <= 0x7fffffff; i += 67108864) {
        long min = i;
        long max = min + 67108864;
        // 筛选出每一个格子里的哈希值数量，java8流统计；https://bugstack.cn/itstack-demo-any/2019/12/10/%E6%9C%89%E7%82%B9%E5%B9%B2%E8%B4%A7-Jdk1.8%E6%96%B0%E7%89%B9%E6%80%A7%E5%AE%9E%E6%88%98%E7%AF%87(41%E4%B8%AA%E6%A1%88%E4%BE%8B).html
        int num = (int) hashCodeList.parallelStream().filter(x -> x >= min && x < max).count();
        statistics.put(start++, num);
    }
    return statistics;

• 这个过程主要统计int取值范围内，每一个哈希值存放到不一样格子里的数量。
• 这里也是使用了java8的新特性语法，统计起来仍是比较方便的。

4.2 单元测试

@Test
public void test_hashArea() {
    System.out.println(HashCode.hashArea(words, 2).values());
    System.out.println(HashCode.hashArea(words, 7).values());
    System.out.println(HashCode.hashArea(words, 31).values());
    System.out.println(HashCode.hashArea(words, 32).values());
    System.out.println(HashCode.hashArea(words, 199).values());
}

• 这里列出咱们要统计的乘数值，每个乘数下都会有对应的哈希值数量汇总，也就是64个格子里的数量。
• 最终把这些统计值放入到excel中进行图表化展现。

统计图表

• 以上是一个堆积百分比统计图，能够看到下方是不一样乘数下的，每一个格子里的数据统计。
• 除了199不能用之外，31的散列结果相对来讲比较均匀。

4.2.1 乘数2散列

• 乘数是2的时候，散列的结果基本都堆积在中间，没有很好的散列。

4.2.2 乘数31散列

• 乘数是31的时候，散列的效果就很是明显了，基本在每一个范围都有数据存放。

4.2.3 乘数199散列

• 乘数是199是不能用的散列结果，可是它的数据是更加分散的，从图上能看到有两个小山包。但由于数据区间问题会有数据丢失问题，因此不能选择。

文中引用

• http://www.tianxiaobo.com/201...
• https://stackoverflow.com/que...

5、总结

• 以上主要介绍了hashCode选择31做为乘数的主要缘由和实验数据验证，算是一个散列的数据结构的案例讲解，在后续的相似技术中，就能够解释其余的源码设计思路了。
• 看过本文至少应该让你能够从根本上解释了hashCode的设计，关于他的全部问题也就不须要死记硬背了，学习编程内容除了最开始的模仿到深刻之后就须要不断的研究数学逻辑和数据结构。
• 文中参考了优秀的hashCode资料和stackoverflow，并亲自作实验验证结果，你们也能够下载本文中资源内容；英文字典、源码、excel图表等内容。

6、推荐阅读

• 面经手册 · 开篇《面试官都问我啥》
• 工做两年简历写成这样，谁要你呀！
• 讲道理，只要你是一个爱折腾的程序员，毕业找工做真的不须要再花钱培训！
• 大学四年到毕业工做5年的学习路线资源汇总
• 手写mybait-spring核心功能(干货好文一次学会工厂bean、类代理、bean注册的使用)
• 源码分析 | Mybatis接口没有实现类为何能够执行增删改查