String.hashCode() 31？

所谓世事洞明皆学问，在String.hashCode()中为何选择 31 作为魔数？

public int hashCode() {                          
    int h = hash;//缓存该 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;                                    
}                                                

Effective Java 大法好：

之所以选择 31，是因为它是个奇素数，如果乘数是偶数，并且乘法溢出的话，信息就会丢失，因为与2相乘等价于移位运算。使用素数的好处并不是很明显，但是习惯上都使用素数来计算散列结果。31 有个很好的特性，就是用移位和减法来代替乘法，可以得到更好的性能：31 * i == (i << 5) - i。现在的VM可以自动完成这种优化。

使用 MAC 下的字典文件做测试：

cat /usr/share/dict/words | wc -l
235886

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class StringHashCodeTest {

    public static int hashCode(char[] value, int prim) {
        int h = 0;
        for (int i = 0; i < value.length; i++) {
            h = prim * h + value[i];
        }
        return h;
    }

    public static void calculateConflictRate(Integer multiplier, List<Integer> hashes) {
        Comparator<Integer> cp = (x, y) -> x > y ? 1 : (x < y ? -1 : 0);
        // 最大的 hashCode
        int maxHash = hashes.stream().max(cp).get();
        // 最小的 hashCode
        int minHash = hashes.stream().min(cp).get();

        // 没有冲突的 hashCode 累计和
        int uniqueHashNum = (int) hashes.stream().distinct().count();
        // 冲突的 hashCode 累计和
        int conflictNum = hashes.size() - uniqueHashNum;
        // 冲突率
        double conflictRate = (conflictNum * 1.0) / hashes.size();

        System.out.println(String.format("multiplier=%4d, minHash=%11d, maxHash=%10d, conflictNum=%6d, conflictRate=%.4f%%",
                multiplier, minHash, maxHash, conflictNum, conflictRate * 100));
    }

    public static void main(String[] args) throws IOException {
        List<String> list = new ArrayList<>(235886);
        Reader reader = new FileReader("/usr/share/dict/words");
        BufferedReader bufferedReader = new BufferedReader(reader);
        String string;
        while ((string = bufferedReader.readLine()) != null) {
            list.add(string);
        }
        bufferedReader.close();
        reader.close();

        if (args == null || args.length == 0) {
            return;
        }

        for (String arg : args) {
            int prim = Integer.valueOf(arg);
            List<Integer> result = new ArrayList<>();
            for (String s : list) {
                result.add(hashCode(s.toCharArray(), prim));
            }
            calculateConflictRate(prim, result);
        }
    }
}

String.hashCode() 生成哈希码二进制序列每一位为1的概率

package cn.bjut.test;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class Main {

    public static int hashCode(char[] value, int prim) {
        int h = 0;
        for (int i = 0; i < value.length; i++) {
            h = prim * h + value[i];
        }
        return h;
    }

    public static void main(String[] args) throws IOException {

        Reader reader = new FileReader("/usr/share/dict/words");
        BufferedReader bufferedReader = new BufferedReader(reader);
        String string;
        int[] res = new int[32];
        int len = 0;
        while ((string = bufferedReader.readLine()) != null) {
            len++;
            String s = Integer.toBinaryString(hashCode(string.toCharArray(), 32));
            s = new StringBuilder(s).reverse().toString();
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '1') {
                    res[i]++;
                }
            }
        }
        System.out.println("len = " + len);
        for (int i = 31; i >= 0; i--) {
            System.out.printf("%d  %.3f\n", i, res[i] * 1.0 / len);
        }
        bufferedReader.close();
        reader.close();
    }
}

32：

len = 235886
31  0.458
30  0.413
29  0.469
28  0.369
27  0.515
26  0.465
25  0.435
24  0.440
23  0.381
22  0.562
21  0.441
20  0.377
19  0.508
18  0.378
17  0.593
16  0.457
15  0.488
14  0.393
13  0.486
12  0.614
11  0.398
10  0.348
9  0.473
8  0.464
7  0.603
6  0.409
5  0.349
4  0.375
3  0.357
2  0.550
1  0.367
0  0.616

31：

len = 235886
31  0.502
30  0.472
29  0.467
28  0.455
27  0.470
26  0.506
25  0.487
24  0.479
23  0.493
22  0.484
21  0.501
20  0.497
19  0.494
18  0.500
17  0.497
16  0.503
15  0.503
14  0.498
13  0.500
12  0.499
11  0.503
10  0.498
9  0.500
8  0.498
7  0.500
6  0.501
5  0.500
4  0.500
3  0.499
2  0.502
1  0.499
0  0.499

可以看到使用 31 每一位为 1 的概率接近 50%

https://www.zhihu.com/question/24381016/answer/433065601
https://segmentfault.com/a/1190000010799123