Java 构建 HashCode 相同的字符串

在查看 hashcode 源码的时候，想模拟红黑树的生成，发现不知如何构建 HashCode 相同的值。

从源码看HashCode 的生成(jdk1.8 为例)

• 都知道 Object 有一个通用的 hashcode() 方法，但该方法被 native 修饰，无从下手

public native int hashCode();

• 再来看 String 类重写的 hashCode()

public int hashCode() {
    int h = hash; // 计算过 hash，直接取值
    /* 遍历字符串的每一个值 */
    if (h == 0 && value.length > 0) {
        char val[] = value;
		/* 可以看到规律，第一个值 * 31 + 第二个值
		HashCode(S)=S[0]∗31^n−1+S[1]∗31^n−2+...+S[n−2]∗31+S[n−1] */
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

• 看下 Integer 的 hashCode() 方法，返回本身的值，想得到相同的 hashcode 还是算了吧。

@Override
public int hashCode() {
    return Integer.hashCode(value);
}
public static int hashCode(int value) {
    return value;
}

HashCode 相同的字符串的生成

• 已字符串长度为 2 为例，数学题开始，若要两个字符串相等
  • a1 * 31 + a2 = b1 * 31 + b2 <==> 31 * (a1 - b1) = b2 - a2，那么，若 a1 - b1 = 1，b2 - a2 = 31 则可以得到相同的hashcode。
  • 根据 ASCII 可知，大小写字母之间相差32，如 A = 65,B = 66, a = 97，那么 B - A = 1, a - B = 31。即 “BB”.hashcode() == “Aa”.hashcode()。
• 来个测试

public class HashCodeGenerate01 {
    public static void main(String[] args) {
        String str01 = "Aa";
        String str02 = "BB";
        System.out.println("Aa.hashCode(): " + str01.hashCode());
        System.out.println("BB.hashCode(): " + str02.hashCode());
        System.out.println("65 * 31 + 97 = " + (65 * 31 + 97));
        System.out.println("66 * 31 + 66 = " + (66 * 31 + 66));
    }
}

生成多个 HashCode 相同的值

• 很简单，AA 与 Bb 相等，AAAA 与 BbBb 也肯定相等，只是为了演示，就不去搞那些花里胡哨的了。

import java.util.ArrayList;
import java.util.List;

public class HashCodeGenerate02 {
    private static String[] base = new String[] {"Aa", "BB"};
    /* 生成 2^n 个值 */
    public static List<String> generateN(int n) {
        if(n <= 0) return null;

        List<String> list = generateOne(null);
        for(int i = 1; i < n; ++i) {
            list = generateOne(list);
        }

        return list;
    }
    /* 生成 2 个 hashcode 相同的值 */
    public static List<String> generateOne() {
        return generateOne(null);
    }

    public static List<String> generateOne(List<String> strList) {
        if((null == strList) || (0 == strList.size())) {
            strList = new ArrayList<String>();
            for(int i = 0; i < base.length; ++i) {
                strList.add(base[i]);
            }

            return strList;
        }

        List<String> result = new ArrayList<String>();

        for(int i = 0; i < base.length; ++i) {
            for(String str: strList) {
                result.add(base[i]  + str);
            }
        }

        return result;
    }
    public static void main(String[] args) {
        System.out.println("generateOne(): " + generateOne());
        System.out.println("generateN(2): " + generateN(2));
        System.out.println("generateN(3): " + generateN(3));
        System.out.print("generateN(3) 的hashcode：" + "\t");
        List<String> list = generateN(3);
        for (String str : list) {
            System.out.print(str.hashCode() + "\t");
        }
    }
}

总结

• hashcode 的计算公式为 HashCode(S)=S[0]∗31^{n−1+S[1]∗31}n−2+…+S[n−2]∗31+S[n−1] ，遵循其规律，无数个 Hashcode 相同的值在等着你。