一文说透 String 的 HashCode

首先需要明确版本，不同版本的实现是不同的。

JDK 1.8 以前

底层的实现是 char[]。

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;
}

举个栗子：

计算 "ab" 的 hashCode

1. h = 31 * 0 + 97 = 97

2. h = 31 * 97 + 98 = 3105

JDK 1.8 及之后

底层变为了 byte[] + coder（编码）

private final byte[] value;

private final byte coder; // 识别是什么编码

public int hashCode() {
	int h = hash;
	if (h == 0 && !hashIsZero) {
		h = isLatin1() ? StringLatin1.hashCode(value)
					   : StringUTF16.hashCode(value);
		if (h == 0) {
			hashIsZero = true;
		} else {
			hash = h;
		}
	}
	return h;
}

isLatin1 也就是判断是不是单字节，走对应的方法计算 hashCode。

以下是单字节的计算方式。

public static int hashCode(byte[] value) {
	int h = 0;
	for (byte v : value) {
		h = 31 * h + (v & 0xff);
	}
	return h;
}

其实也没什么高大上的，只是使用位运算来提高效率而已。v & 0xff（全1）能保证值一直为 v。

举个例子：还是"ab"

存储在 byte[] 中就是 [97, 98]

1. h = 31 * 0 + (97 & 255) = 31 * 0 + (0110 0001 & 1111 1111) = 0110 0001 = 97

2. h = 31 * 97 + (98 ^ 255) = 31 * 97 + ( 0110 0010 & 1111 1111) = 0110 0010 = 3105

以下是双字节（四字节...偶数字节）的计算方式。

public static int hashCode(byte[] value) {
	int h = 0;
	int length = value.length >> 1;
	for (int i = 0; i < length; i++) {
		h = 31 * h + getChar(value, i);
	}
	return h;
}


@IntrinsicCandidate
// intrinsic performs no bounds checks
static char getChar(byte[] val, int index) {
	assert index >= 0 && index < length(val) : "Trusted caller missed bounds check";
	index <<= 1;
	return (char)(((val[index++] & 0xff) << HI_BYTE_SHIFT) |
				  ((val[index]   & 0xff) << LO_BYTE_SHIFT));
}


/* 确定系统字节序
isBigEndian() 是一个本地方法（native method），它返回一个布尔值来指示系统的字节序是否为大端模式（big-endian）。
在大端模式下，最高有效字节（most significant byte, MSB）存储在最低地址处；而在小端模式（little-endian）下，最高有效字节存储在最高地址处。
*/
private static native boolean isBigEndian();

static final int HI_BYTE_SHIFT;
static final int LO_BYTE_SHIFT;
static {
	if (isBigEndian()) {
		HI_BYTE_SHIFT = 8;
		LO_BYTE_SHIFT = 0;
	} else {
		HI_BYTE_SHIFT = 0;
		LO_BYTE_SHIFT = 8;
	}
}

双字节的其实也是一样的实现，只是多了一个区分系统字节序的操作。

相同hasdCode的字符串

由于 公式为 h = 31 * h + val[i];

即 a1 * 31 + a2 = b1 * 31 + b2

31 * (a1 - b1) = b2 - a2

若 a1 - b1 = 1，b2 - a2 = 31, 此时 HashCode 相同

根据 ASCII 可知，大小写字母之间相差32，那么像 A、b这样的字符就刚好相差 31。

那么，类似于 Aa、BB 这样的字符串的 hashCode 就一定是相同的。

可以测试一下，结果显然是正确的。

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));

以下是 JAVA 代码实现：

public class HashCodeGenerate {
    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");
        }
    }
}