最近我读了这篇文章 开发人员工作文件。
该文档是关于有效和正确地定义hashCode()和equals()，但我无法弄清楚为什么我们需要覆盖这两个方法。
我如何决定有效地实现这些方法?
当前回答
为什么重写equals()方法
在Java中，我们不能重载==、+=、-+等操作符的行为。他们的行为是特定的。让我们关注一下这里的运算符==。
operator ==如何工作。
它检查我们比较的两个引用是否指向内存中的同一个实例。只有当这两个引用表示内存中的同一个实例时，Operator ==才会解析为true。
现在让我们考虑下面的例子
public class Person {
private Integer age;
private String name;
..getters, setters, constructors
}
假设在你的程序中，你在不同的地方建立了2个Person对象，你希望比较它们。
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1 == person2 ); --> will print false!
这两个对象从商业角度看是一样的，对吧?对于JVM，它们是不一样的。因为它们都是用new关键字创建的，所以这些实例位于内存中的不同段中。因此运算符==将返回false
但是如果我们不能重写==操作符，我们怎么能对JVM说我们希望这两个对象被视为相同的。这里出现了.equals()方法。
您可以重写equals()来检查某些对象是否具有相同的值，以便将特定字段视为相等。
您可以选择要比较的字段。如果我们说2个Person对象当且仅当它们具有相同的年龄和相同的名称时是相同的，那么IDE将为自动生成equals()创建如下内容
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
让我们回到前面的例子
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1 == person2 ); --> will print false!
System.out.println ( person1.equals(person2) ); --> will print true!
所以我们不能重载==运算符来以我们想要的方式比较对象，但是Java给了我们另一种方法，equals()方法，我们可以随心所欲地重写它。
但是请记住，如果我们没有在我们的类中提供.equals()的自定义版本(也就是重写)，那么Object类和==操作符中预定义的.equals()将表现完全相同。
从Object继承的默认equals()方法将检查两个比较实例在内存中是否相同!
为什么重写hashCode()方法
java中的一些数据结构(如HashSet, HashMap)基于应用于这些元素上的哈希函数来存储它们的元素。哈希函数是hashCode()
如果我们可以选择重写.equals()方法，那么我们也必须选择重写hashCode()方法。这是有原因的。
继承自Object的hashCode()的默认实现认为内存中的所有对象都是唯一的!
让我们回到哈希数据结构。对于这些数据结构有一个规则。
HashSet不能包含重复的值，HashMap不能包含重复的键
HashSet是在幕后使用HashMap实现的，HashSet的每个值都存储为HashMap中的一个键。
所以我们必须理解HashMap是如何工作的。
简单地说，HashMap是一个具有一些桶的原生数组。每个桶都有一个linkedList。在那个linkedList中存储了我们的键。HashMap通过应用hashCode()方法为每个键定位正确的linkedList，然后它遍历该linkedList中的所有元素，并对每个元素应用equals()方法，以检查该元素是否已经包含在其中。不允许重复密钥。
当我们在HashMap中放东西时，键就存储在其中一个linkedlist中。该键将存储在哪个linkedList中，由该键上的hashCode()方法的结果显示。因此，如果key1. hashcode()的结果是4，那么key1将存储在数组的第4个桶中，在那里存在的linkedList中。
默认情况下，hashCode()方法为每个不同的实例返回不同的结果。如果我们有默认的equals()，它的行为类似于==，它将内存中的所有实例视为不同的对象，我们就没有任何问题。
但在前面的示例中，我们说过，如果Person实例的年龄和名字匹配，则认为Person实例是相等的。
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1.equals(person2) ); --> will print true!
现在让我们创建一个映射，将这些实例存储为键，并使用一些字符串作为pair值
Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");
在Person类中，我们没有重写hashCode方法，但我们重写了equals方法。由于默认的hashCode为不同的java实例提供不同的结果，person1.hashCode()和person2.hashCode()很有可能得到不同的结果。
我们的映射可能以这些人在不同的链表中结束。
这违背了HashMap的逻辑
一个HashMap不允许有多个相等的键!
但是我们现在有了，原因是从对象类继承的默认hashCode()是不够的。在Person类上重写equals()方法之后就不会了。
这就是为什么我们必须在重写equals方法之后重写hashCode()方法的原因。
现在我们来解决这个问题。让我们重写hashCode()方法来考虑equals()考虑的相同字段，即年龄、姓名
public class Person {
private Integer age;
private String name;
..getters, setters, constructors
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
现在让我们再次尝试将这些键保存到HashMap中
Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");
person1.hashCode()和person2.hashCode()肯定是相同的。假设它是0。
HashMap将进入0桶，在LinkedList中将person1保存为值为“1”的键。对于第二次放置HashMap是足够智能的，当它再次到bucket 0保存值为“2”的person2 key时，它将看到另一个相等的key已经存在于那里。它会覆盖之前的键。最后HashMap中只有person2键。
现在我们与哈希映射规则保持一致，该规则说不允许有多个相等的键!
其他回答
为了在HashMap, Hashtable等集合中使用我们自己的类对象作为键。，我们应该通过了解集合的内部工作来重写这两个方法(hashCode()和equals())。否则，它会导致我们意想不到的错误结果。
The methods equals and hashcode are defined in the object class. By default if the equals method returns true, then the system will go further and check the value of the hash code. If the hash code of the 2 objects is also same only then the objects will be considered as same. So if you override only equals method, then even though the overridden equals method indicates 2 objects to be equal , the system defined hashcode may not indicate that the 2 objects are equal. So we need to override hash code as well.
为什么重写equals()方法
在Java中，我们不能重载==、+=、-+等操作符的行为。他们的行为是特定的。让我们关注一下这里的运算符==。
operator ==如何工作。
它检查我们比较的两个引用是否指向内存中的同一个实例。只有当这两个引用表示内存中的同一个实例时，Operator ==才会解析为true。
现在让我们考虑下面的例子
public class Person {
private Integer age;
private String name;
..getters, setters, constructors
}
假设在你的程序中，你在不同的地方建立了2个Person对象，你希望比较它们。
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1 == person2 ); --> will print false!
这两个对象从商业角度看是一样的，对吧?对于JVM，它们是不一样的。因为它们都是用new关键字创建的，所以这些实例位于内存中的不同段中。因此运算符==将返回false
但是如果我们不能重写==操作符，我们怎么能对JVM说我们希望这两个对象被视为相同的。这里出现了.equals()方法。
您可以重写equals()来检查某些对象是否具有相同的值，以便将特定字段视为相等。
您可以选择要比较的字段。如果我们说2个Person对象当且仅当它们具有相同的年龄和相同的名称时是相同的，那么IDE将为自动生成equals()创建如下内容
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
让我们回到前面的例子
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1 == person2 ); --> will print false!
System.out.println ( person1.equals(person2) ); --> will print true!
所以我们不能重载==运算符来以我们想要的方式比较对象，但是Java给了我们另一种方法，equals()方法，我们可以随心所欲地重写它。
但是请记住，如果我们没有在我们的类中提供.equals()的自定义版本(也就是重写)，那么Object类和==操作符中预定义的.equals()将表现完全相同。
从Object继承的默认equals()方法将检查两个比较实例在内存中是否相同!
为什么重写hashCode()方法
java中的一些数据结构(如HashSet, HashMap)基于应用于这些元素上的哈希函数来存储它们的元素。哈希函数是hashCode()
如果我们可以选择重写.equals()方法，那么我们也必须选择重写hashCode()方法。这是有原因的。
继承自Object的hashCode()的默认实现认为内存中的所有对象都是唯一的!
让我们回到哈希数据结构。对于这些数据结构有一个规则。
HashSet不能包含重复的值，HashMap不能包含重复的键
HashSet是在幕后使用HashMap实现的，HashSet的每个值都存储为HashMap中的一个键。
所以我们必须理解HashMap是如何工作的。
简单地说，HashMap是一个具有一些桶的原生数组。每个桶都有一个linkedList。在那个linkedList中存储了我们的键。HashMap通过应用hashCode()方法为每个键定位正确的linkedList，然后它遍历该linkedList中的所有元素，并对每个元素应用equals()方法，以检查该元素是否已经包含在其中。不允许重复密钥。
当我们在HashMap中放东西时，键就存储在其中一个linkedlist中。该键将存储在哪个linkedList中，由该键上的hashCode()方法的结果显示。因此，如果key1. hashcode()的结果是4，那么key1将存储在数组的第4个桶中，在那里存在的linkedList中。
默认情况下，hashCode()方法为每个不同的实例返回不同的结果。如果我们有默认的equals()，它的行为类似于==，它将内存中的所有实例视为不同的对象，我们就没有任何问题。
但在前面的示例中，我们说过，如果Person实例的年龄和名字匹配，则认为Person实例是相等的。
Person person1 = new Person("Mike", 34);
Person person2 = new Person("Mike", 34);
System.out.println ( person1.equals(person2) ); --> will print true!
现在让我们创建一个映射，将这些实例存储为键，并使用一些字符串作为pair值
Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");
在Person类中，我们没有重写hashCode方法，但我们重写了equals方法。由于默认的hashCode为不同的java实例提供不同的结果，person1.hashCode()和person2.hashCode()很有可能得到不同的结果。
我们的映射可能以这些人在不同的链表中结束。
这违背了HashMap的逻辑
一个HashMap不允许有多个相等的键!
但是我们现在有了，原因是从对象类继承的默认hashCode()是不够的。在Person类上重写equals()方法之后就不会了。
这就是为什么我们必须在重写equals方法之后重写hashCode()方法的原因。
现在我们来解决这个问题。让我们重写hashCode()方法来考虑equals()考虑的相同字段，即年龄、姓名
public class Person {
private Integer age;
private String name;
..getters, setters, constructors
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
现在让我们再次尝试将这些键保存到HashMap中
Map<Person, String> map = new HashMap();
map.put(person1, "1");
map.put(person2, "2");
person1.hashCode()和person2.hashCode()肯定是相同的。假设它是0。
HashMap将进入0桶，在LinkedList中将person1保存为值为“1”的键。对于第二次放置HashMap是足够智能的，当它再次到bucket 0保存值为“2”的person2 key时，它将看到另一个相等的key已经存在于那里。它会覆盖之前的键。最后HashMap中只有person2键。
现在我们与哈希映射规则保持一致，该规则说不允许有多个相等的键!
简单地说，Object中的equals-方法检查引用是否相等，当属性相等时，类的两个实例在语义上仍然相等。例如，当将对象放入使用等号和hashcode(如HashMap和Set)的容器中时，这很重要。假设我们有这样一个类:
public class Foo {
String id;
String whatevs;
Foo(String id, String whatevs) {
this.id = id;
this.whatevs = whatevs;
}
}
我们创建了两个具有相同id的实例:
Foo a = new Foo("id", "something");
Foo b = new Foo("id", "something else");
如果不重写等号，我们将得到:
A.equals (b)为假，因为它们是两个不同的实例 a.equals(a)为真，因为它是同一个实例 b.equals(b)为真，因为它是同一个实例
正确吗?也许吧，如果这是你想要的。但假设我们希望具有相同id的对象是相同的对象，不管它是否是两个不同的实例。我们重写等号(和hashcode):
public class Foo {
String id;
String whatevs;
Foo(String id, String whatevs) {
this.id = id;
this.whatevs = whatevs;
}
@Override
public boolean equals(Object other) {
if (other instanceof Foo) {
return ((Foo)other).id.equals(this.id);
}
}
@Override
public int hashCode() {
return this.id.hashCode();
}
}
至于实现equals和hashcode，我建议使用Guava的helper方法
如果重写equals()而不是hashcode()，则不会发现任何问题，除非您或其他人在HashSet等散列集合中使用该类类型。 在我之前的人已经清楚地解释了很多次文献理论，我只是在这里提供一个非常简单的例子。
考虑一个类，它的equals()需要表示自定义的东西:-
public class Rishav {
private String rshv;
public Rishav(String rshv) {
this.rshv = rshv;
}
/**
* @return the rshv
*/
public String getRshv() {
return rshv;
}
/**
* @param rshv the rshv to set
*/
public void setRshv(String rshv) {
this.rshv = rshv;
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Rishav) {
obj = (Rishav) obj;
if (this.rshv.equals(((Rishav) obj).getRshv())) {
return true;
} else {
return false;
}
} else {
return false;
}
}
@Override
public int hashCode() {
return rshv.hashCode();
}
}
现在考虑这个主类:-
import java.util.HashSet;
import java.util.Set;
public class TestRishav {
public static void main(String[] args) {
Rishav rA = new Rishav("rishav");
Rishav rB = new Rishav("rishav");
System.out.println(rA.equals(rB));
System.out.println("-----------------------------------");
Set<Rishav> hashed = new HashSet<>();
hashed.add(rA);
System.out.println(hashed.contains(rB));
System.out.println("-----------------------------------");
hashed.add(rB);
System.out.println(hashed.size());
}
}
这将产生以下输出:-
true
-----------------------------------
true
-----------------------------------
1
我对结果很满意。但是如果我没有覆盖hashCode()，它将导致噩梦，因为具有相同成员内容的Rishav对象将不再被视为唯一的hashCode将是不同的，因为由默认行为生成，这里将是输出:-
true
-----------------------------------
false
-----------------------------------
2
推荐文章
- 检查bash变量是否等于0
- 如何分割逗号分隔的字符串?
- Java字符串—查看字符串是否只包含数字而不包含字母
- Mockito.any()传递带有泛型的接口
- 在IntelliJ 10.5中运行测试时，出现“NoSuchMethodError: org.hamcrest. matcher . descripbemismatch”
- 使用String.split()和多个分隔符
- Java数组有最大大小吗?
- 在Android中将字符串转换为Uri
- 从JSON生成Java类?
- 为什么java.util.Set没有get(int index)?
- Swing和AWT的区别是什么?
- 为什么Java流是一次性的?
- 四舍五入BigDecimal *总是*有两位小数点后
- 设计模式:工厂vs工厂方法vs抽象工厂
- Java:检查enum是否包含给定的字符串?
