hashcode在java中主要用于快速比较对象是否相等，尤其是在集合类如hashmap、hashset中，通过hashcode可以大幅提升查找效率。1. 一致性：只要对象的属性没有改变，无论调用多少次hashcode方法，都应该返回相同的值；2. 相等性：如果两个对象通过equals方法比较是相等的，那么它们的hashcode值必须相等；3. 不等性：如果两个对象通过equals方法比较是不相等的，它们的hashcode值最好也不同，这样可以提高哈希表的性能，减少冲突。hashcode和equals的关系是：若两个对象相等（equals返回true），则它们的hashcode必须相同；但若hashcode相同，它们不一定相等。如果不重写hashcode，可能导致使用哈希表时出现逻辑错误，例如内容相同但hashcode不同的对象会被视为不同键。最佳实践包括：基于关键属性生成hashcode、避免使用可变属性、使用objects.hash()方法、考虑性能、进行单元测试验证正确性。只有在对象永远不会放入哈希表、对象不可变且未重写equals、或性能要求极高时，才可以不重写hashcode方法，否则始终应重写以确保程序正确性和性能。
hashCode在Java中主要用于快速比较对象是否相等，尤其是在集合类如HashMap、HashSet中，通过hashCode可以大幅提升查找效率。简单来说，hashCode就像是对象的指纹，可以快速定位对象。
hashCode方法的3个重写原则是：
- 一致性： 只要对象的属性没有改变，无论调用多少次hashCode方法，都应该返回相同的值。
- 相等性： 如果两个对象通过equals方法比较是相等的，那么它们的hashCode值必须相等。
- 不等性： 如果两个对象通过equals方法比较是不相等的，它们的hashCode值最好也不同，这样可以提高哈希表的性能，减少冲突。
hashCode和equals方法到底是什么关系？
hashCode和equals方法是Java中用于比较对象是否相等的两个重要方法。它们之间的关系是：如果两个对象相等（equals方法返回true），那么它们的hashCode值必须相等。反过来，如果两个对象的hashCode值相等，它们不一定相等（equals方法可能返回false）。
这个关系非常重要，尤其是在使用哈希表（如HashMap、HashSet）时。哈希表通过hashCode值来快速定位对象，如果两个相等的对象的hashCode值不同，那么在哈希表中就可能出现逻辑错误。
举个例子，假设你有一个自定义的类Person，并且重写了equals方法，只比较name和age属性。如果你没有重写hashCode方法，那么即使两个Person对象的name和age相同，它们的hashCode值也可能不同，因为默认的hashCode方法是基于对象的内存地址生成的。
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Person person = (Person) obj;
return age == person.age && Objects.equals(name, person.name);
}
// 缺少 hashCode 方法
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Alice", 30);
System.out.println(p1.equals(p2)); // true
System.out.println(p1.hashCode() == p2.hashCode()); // 很有可能 false，因为没有重写hashCode
}
}
在这种情况下，如果你将p1和p2放入HashSet中，HashSet会认为它们是两个不同的对象，因为它们的hashCode值不同，即使它们的name和age相同。这显然是不符合预期的。
因此，当你重写equals方法时，一定要同时重写hashCode方法，以保证相等的对象具有相同的hashCode值。一个简单的hashCode方法实现可以使用Objects.hash()：
import java.util.Objects;
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Person person = (Person) obj;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Alice", 30);
System.out.println(p1.equals(p2)); // true
System.out.println(p1.hashCode() == p2.hashCode()); // true，因为重写了hashCode
}
}
重写hashCode方法时有哪些最佳实践？
重写hashCode方法需要遵循一些最佳实践，以确保其性能和正确性：
- 使用对象的关键属性： hashCode方法应该基于对象中用于equals方法比较的关键属性来生成hashCode值。这意味着如果两个对象的这些关键属性相同，那么它们的hashCode值也应该相同。
- 避免使用可变属性： 尽量避免使用可变属性来生成hashCode值。如果对象的hashCode值在其生命周期内发生改变，那么在使用哈希表时可能会导致问题。
-
使用Objects.hash()： Java 7引入了
Objects.hash()方法，可以方便地为多个属性生成hashCode值。这个方法可以处理null值，并且可以生成一个相对均匀分布的hashCode值。 - 考虑性能： hashCode方法的性能也很重要，因为它会被频繁调用。避免在hashCode方法中进行复杂的计算或IO操作。
- 测试hashCode方法： 编写单元测试来验证hashCode方法的正确性。确保相等的对象具有相同的hashCode值，并且hashCode值在对象的生命周期内不会发生改变。
举个例子，假设你有一个自定义的类Product，它有name、price和description三个属性。其中，只有name和price用于equals方法比较。那么，你可以这样重写hashCode方法：
import java.util.Objects;
class Product {
String name;
double price;
String description;
public Product(String name, double price, String description) {
this.name = name;
this.price = price;
this.description = description;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Product product = (Product) obj;
return Double.compare(product.price, price) == 0 && Objects.equals(name, product.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
}
在这个例子中，hashCode方法只使用了name和price属性，因为它们是equals方法中用于比较的关键属性。description属性被忽略了，因为它不影响对象的相等性。
不重写hashCode方法会怎么样？
如果不重写hashCode方法，那么对象将使用默认的hashCode方法，该方法通常是基于对象的内存地址生成的。这意味着即使两个对象的内容相同，它们的hashCode值也可能不同。
这会导致在使用哈希表（如HashMap、HashSet）时出现问题。例如，如果你将一个对象放入HashSet中，然后修改了该对象的内容，那么HashSet可能无法找到该对象，因为它计算出的hashCode值已经发生了改变。
更糟糕的是，如果你将两个内容相同的对象放入HashMap中，它们会被认为是两个不同的键，因为它们的hashCode值不同。这会导致HashMap的行为变得不可预测。
因此，如果你重写了equals方法，那么一定要同时重写hashCode方法，以保证相等的对象具有相同的hashCode值。这可以避免在使用哈希表时出现问题，并且可以提高程序的性能。
什么时候可以不重写hashCode方法？
在极少数情况下，可以不重写hashCode方法：
- 永远不会将对象放入哈希表中： 如果你确定你的对象永远不会被用作HashMap或HashSet的键，那么可以不重写hashCode方法。但是，这通常是一个坏主意，因为你无法保证将来不会改变这个决定。
- 对象是不可变的： 如果你的对象是不可变的，并且你没有重写equals方法，那么可以不重写hashCode方法。因为默认的hashCode方法是基于对象的内存地址生成的，而不可变对象的内存地址在其生命周期内不会发生改变。
- 性能要求极高： 在某些性能要求极高的场景下，可以考虑牺牲hashCode的正确性来提高性能。但是，这通常是一个非常危险的做法，因为它可能会导致难以调试的错误。
总的来说，重写hashCode方法是一个良好的编程习惯。它可以避免在使用哈希表时出现问题，并且可以提高程序的性能。除非你有非常充分的理由，否则应该始终重写hashCode方法。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
