在java中，若需为字符串实现自定义哈希函数（例如，基于字符ascii值求和），并将其应用于哈希表等数据结构而不必从头构建哈希表，核心策略是创建一个包装类。该包装类持有原始字符串，并重写其`hashcode()`方法以实现自定义哈希逻辑，同时必须重写`equals()`方法以维护哈希契约，从而确保自定义哈希行为在集合中正确生效。
核心原理：重写hashCode()与equals()
Java中的String类默认提供了一个高效的hashCode()实现，它基于s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]的算法。然而，在某些特定场景下，开发者可能希望使用更简单或符合特定业务逻辑的哈希算法，例如，仅仅将字符串中所有字符的ASCII值相加。
直接修改java.lang.String类的hashCode()方法是不可能的，因为它是JDK的一部分。解决方案是创建一个自定义的字符串包装类。当我们将对象存储到HashMap、HashSet等基于哈希的数据结构中时，这些结构会依赖对象的hashCode()方法来确定存储位置（桶），并依赖equals()方法来解决哈希冲突并判断对象是否真正相等。
因此，要实现自定义哈希行为，我们需要遵循以下两个关键原则：
- 创建包装类： 将原始String对象封装在一个新的自定义类中。
- 重写hashCode()和equals()： 在这个包装类中，我们需要同时重写hashCode()方法以实现自定义的哈希逻辑，并重写equals()方法以维护两者之间的契约。
equals()和hashCode()的契约：
立即学习“Java免费学习笔记（深入）”；
- 如果两个对象通过equals(Object obj)方法比较为相等，那么它们的hashCode()方法必须产生相同的整数结果。
- 如果两个对象通过equals(Object obj)方法比较为不相等，它们的hashCode()方法可以相同也可以不同。然而，为了提高哈希表的性能，理想情况下不相等的对象应具有不同的哈希码。
实现自定义哈希函数的步骤
我们将创建一个名为MyString的包装类，它将包含一个String类型的字段，并重写hashCode()和equals()方法。
1. 创建字符串包装类
首先，定义一个简单的类来包装Java的String对象。为了确保哈希值在对象生命周期内保持不变，内部的String字段应声明为final。
import java.util.Objects;
public class MyString {
private final String value; // 包装的原始字符串，声明为final以确保不可变性
public MyString(String value) {
this.value = value;
}
public String getValue() {
return value;
}
// hashCode() 和 equals() 方法将在下面实现
}2. 实现自定义hashCode()方法
根据需求，我们将实现一个简单的哈希函数，它将字符串中所有字符的ASCII值相加。Java 8及以上版本可以通过codePoints().sum()方法方便地实现这一点，它能正确处理Unicode字符。
import java.util.Objects;
public class MyString {
private final String value;
public MyString(String value) {
this.value = value;
}
public String getValue() {
return value;
}
@Override
public int hashCode() {
// 实现自定义的哈希逻辑：例如，所有字符的Unicode码点（等同于ASCII值对于基本ASCII字符）之和
return value.codePoints().sum();
}
// equals() 方法将在下面实现
}3. 重写equals()方法
为了维护equals()和hashCode()的契约，并且确保HashMap等能够正确地识别对象，我们必须重写equals()方法。标准的实现方式是：
- 检查对象引用是否相同（this == o）。
- 检查传入对象是否为null或类型是否不同。
- 将传入对象向下转型，并比较其内部的value字段。
import java.util.Objects;
public class MyString {
private final String value;
public MyString(String value) {
this.value = value;
}
public String getValue() {
return value;
}
@Override
public int hashCode() {
return value.codePoints().sum();
}
@Override
public boolean equals(Object o) {
// 1. 检查是否为同一对象引用
if (this == o) return true;
// 2. 检查传入对象是否为null或类型是否不匹配
if (o == null || getClass() != o.getClass()) return false;
// 3. 向下转型，并比较内部的value字段
MyString myString = (MyString) o;
return Objects.equals(value, myString.value);
}
}在哈希结构中使用自定义字符串
现在，我们可以在HashMap或HashSet等哈希数据结构中使用MyString类的对象了。这些结构将使用我们自定义的hashCode()和equals()方法。
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map myMap = new HashMap<>();
MyString s1 = new MyString("hello");
MyString s2 = new MyString("world");
MyString s3 = new MyString("olleh"); // "olleh"是"hello"的反转，它们的字符ASCII和相同
MyString s4 = new MyString("hello"); // 与s1内容相同
System.out.println("s1 ('hello') hash: " + s1.hashCode()); // 预期为 104+101+108+108+111 = 532
System.out.println("s3 ('olleh') hash: " + s3.hashCode()); // 预期为 111+108+108+101+104 = 532 (与s1相同)
System.out.println("s4 ('hello') hash: " + s4.hashCode()); // 预期为 532 (与s1相同)
myMap.put(s1, "Value for hello_1");
myMap.put(s2, "Value for world");
myMap.put(s3, "Value for olleh");
myMap.put(s4, "Value for hello_2"); // s4与s1的equals为true，因此会覆盖s1对应的值
System.out.println("--- Map 内容 ---");
System.out.println("Map contains 'hello': " + myMap.get(new MyString("hello"))); // 应该得到 "Value for hello_2"
System.out.println("Map contains 'world': " + myMap.get(new MyString("world"))); // 应该得到 "Value for world"
System.out.println("Map contains 'olleh': " + myMap.get(new MyString("olleh"))); // 应该得到 "Value for olleh"
System.out.println("Map size: " + myMap.size()); // 预期为 3 (s1和s4被视为同一个键)
// 验证哈希冲突处理
// 注意：尽管s1和s3的hashCode相同，但由于equals方法比较的是底层字符串的实际内容（"hello" != "olleh"），
// 它们被视为不同的键，会存储为两个独立的条目。
// 而s1和s4的hashCode相同，且equals方法也相同（"hello" == "hello"），
// 因此s4的put操作会覆盖s1对应的值，最终map中只保留一个"hello"键。
}
} 运行上述代码，你将看到s1、s3、s4具有相同的哈希值（532），但s1.equals(s3)为false，s1.equals(s4)为true。这证明了HashMap会先根据hashCode()找到可能的桶，然后通过equals()最终确定键的唯一性。
注意事项
- equals()与hashCode()的契约至关重要： 务必确保如果两个对象根据equals()方法被认为是相等的，那么它们的hashCode()方法必须返回相同的值。违反此契约会导致哈希表行为异常，例如无法正确查找已存在的元素。
- 哈希函数的设计： 简单的ASCII值求和作为哈希函数，其冲突率可能较高，尤其是在字符串长度和字符组合多样时。例如，"ab"和"ba"会产生相同的哈希值。高冲突率会降低哈希表的性能，因为更多的查找操作需要依赖equals()方法，从而退化为链表遍历。Java默认的String.hashCode()算法经过精心设计，旨在提供良好的分布性和较低的冲突率。
- 性能考量： 自定义哈希函数可能不如JVM内置的String.hashCode()优化，尤其是在处理大量字符串或对性能要求极高的场景下。在决定使用自定义哈希函数时，应权衡其带来的功能性收益与潜在的性能开销。
- 对象不可变性： 包装类中用于计算哈希值的字段（例如MyString中的value）应是不可变的（通过final修饰），以确保对象的哈希值在其生命周期内保持稳定。如果对象在放入哈希表后其哈希值发生变化，那么在后续查找时将无法找到该对象。
总结
通过创建一个简单的包装类并重写其hashCode()和equals()方法，我们可以有效地为String对象实现自定义的哈希逻辑，并将其无缝集成到Java的哈希数据结构中，而无需从头实现一个哈希表。这种方法提供了一种灵活且符合Java设计模式的解决方案，允许开发者根据特定需求调整哈希行为，同时保持了与现有Java集合框架的兼容性。然而，在实现自定义哈希函数时，务必牢记equals()和hashCode()的契约以及哈希函数设计对性能的影响。
