首先需要明确版本,不同版本的实现是不同的。
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");
}
}
}