前言
这篇文章主要帮你理解equal()和hashcode()这两个方法,而后你可以将它们应用到实际工程中;
在使用Java中collections时,添加collections中的某个元素的类的时候,应该适当覆盖equal()和hashcode(),否则会出错;
Object类(java中所有类的父类)定义了两个方法equals()和hashCode(),这意味着java中所有的类(包括我们自己创建的类)都将继承这些方法.
但是,对于将对象添加到collections中的类,必须重写这两方法,尤其是基于哈希表的集合,例如:HashSet和HashMap;
equals()方法的理解
当比较两个对象的时候,java就调用equals()方法,如果两个对象相等,则返回true,否则返回false;(注意:equal()与==是有很大区别的)
区别在于:
equals()比较的是两个对象的数据成员,而==比较的是两个对象的引用(即内存地址)
注意:object类中的equals()比较的是两个对象的引用,我们自己在写类的时候必须将这个方法覆盖以进行语义比较;
JDK中几乎所有的类都有自己的equals()方法,比如String，Date,Integer，Double等;
看下面的一个例子:
String s1 = new String("This is a string");
String s2 = new String("This is a string");
boolean refEqual = (s1 == s2);
boolean secEqual = (s1.equals(s2));
System.out.println("s1 == s2: " + refEqual);
System.out.println("s1.equals(s2): " + secEqual);
你能猜到结果么,请看:
s1 == s2: false
s1.equals(s2): true
你可以看到,引用比较(==操作符)返回false;因为s1和s2是存储在内存中的不同地址;
而语义比较返回true,因为这两个字符串的值相同(同一个字符串),故可以认定其语义是相等 的;
再看一个例子:
public class Student {
private String id;
private String name;
private String email;
private int age;
public Student(String id, String name, String email, int age) {
this.id = id;
this.name = name;
this.email = email;
this.age = age;
}
public String toString() {
String studentInfo = "Student " + id;
studentInfo += ": " + name;
studentInfo += " - " + email;
studentInfo += " - " + age;
return studentInfo;
}
}
如果两个Student对象具有相同的属性(id、姓名、电子邮件和年龄)，则可以认为它们在语义上是相等的。现在，让我们看看如何在这个类中重写equals()方法来确认两个具有相同属性的学生对象是相等的;
public boolean equals(Object obj) {
if (obj instanceof Student) {
Student another = (Student) obj;
if (this.id.equals(another.id) &&
this.name.equals(another.name) &&
this.email.equals(another.email) &&
this.age == another.age) {
return true;
}
}
return false;
}
在这里，此equals()方法检查传递的对象是否为Student类型，以及它是否具有与当前对象相同的属性，相同则(返回true)；否则,返回false。 让我们用以下代码进行测试：
Student student1 = new Student("123", "Tom", "[email protected]", 30);
Student student2 = new Student("123", "Tom", "[email protected]", 30);
Student student3 = new Student("456", "Peter", "[email protected]", 23);
System.out.println("student1 == student2: " + (student1 == student2));
System.out.println("student1.equals(student2): " + (student1.equals(student2)));
System.out.println("student2.equals(student3): " + (student2.equals(student3)));
测试结果:
student1 == student2: false
student1.equals(student2): true
student2.equals(student3): false
让我们来看另一个示例,以理解重写equals()方法的作用。假设我们有一个这样的学生列表
List listStudents = new ArrayList<>();
此列表包含上面的三个Student对象：
listStudents.add(student1);
listStudents.add(student2);
listStudents.add(student3);
现在，我们要检查列表中是否包含具有给定ID的学生。 我会告诉您一个使用equals()方法的简单有趣的解决方案。
请注意，List接口提供了contains(Object)方法，该方法可用于检查列表中是否存在指定的对象。 在后台,列表调用搜索对象上的equals()方法将其与集合中的其他对象进行比较。
如果两个Student对象有相同的ID，是否可以认为它们是相等的?所以我们像这样更新Student类中的equals()方法;
public boolean equals(Object obj) {
if (obj instanceof Student) {
Student another = (Student) obj;
if (this.id.equals(another.id)) {
return true;
}
}
return false;
}
在这里,此equals()方法仅比较两个Student对象的ID属性。 并将另一个构造函数添加至Student类：
public Student(String id) {
this.id = id;
}
现在，我们可以执行如下检查:
Student searchStudent1 = new Student("123");
Student searchStudent4 = new Student("789");
boolean found1 = listStudents.contains(searchStudent1);
boolean found4 = listStudents.contains(searchStudent4);
System.out.println("Found student1: " + found1);
System.out.println("Found student4: " + found4);
结果如下:
Found student1: true
Found student4: false
多亏了equals()方法，使我们的代码变得简单.想象一下,如果不使用它，我们将实现更复杂的搜索功能，如下所示：
public boolean searchStudent(List listStudents, String id) {
for (Student student : listStudents) {
if (student.getId().equals(id)) {
return true;
}
}
return false;
}
HashCode的理解
Object类定义hashCode()方法，如下所示：
public int hashCode()
您可以看到这个方法返回一个整数.那么它在哪里呢?
基于哈希表的集合(如Hashtable,HashSet和HashMap)使用此哈希数将对象存储在称为“存储桶”的小容器中. 每个存储桶都与一个哈希码相关联，每个存储桶仅包含具有相同哈希码的对象。
换句话说，哈希表通过其哈希码值将其元素分组。 这种安排通过搜索集合的一小部分而不是整个集合来帮助哈希表快速有效地定位元素。
以下是在哈希表中定位元素的步骤:
获取指定元素的哈希码值。 这里hashCode()方法将被调用。
找到与该哈希码关联的正确存储桶。
在存储桶内部,通过将指定元素与存储桶中的所有元素进行比较,找到正确的元素.这将导致调用指定元素的equals()方法。
当我们将类的对象添加到基于哈希表的集合(HashSet,HashMap)时,该类的hashCode()方法将被调用以产生一个整数(可以是任意值),集合使用此数字来快速有效地存储和定位对象,因为基于哈希表的集合不会保持其元素的顺序。
注意:Object类中hashCode()的默认实现返回一个整数,该整数是对象的内存地址.我们应该在自己的类中重写它. JDK中的几乎所有类都会覆盖其自己的hashCode()方法版本,例如String,Date,Integer,Double等。
hashcode()和equals()之间的规则与约定
如上所述，基于哈希表的集合由于是通过调用元素的hashCode()和equals()方法来定位元素，因此对于重写这些方法的方式，我们必须遵守此约定：
当equals()方法被覆盖时，hashCode()方法也必须被覆盖。
如果两个对象相等,则它们的哈希码也必须相等。
如果两个对象不相等,则它们的哈希码没有限制(它们的哈希码可以相等或不相等).
如果两个对象具有相同的哈希码,则它们的相等性不受限制(它们可以相等或不相等).
如果两个对象具有不同的哈希码,则它们不能相等。
通过遵循这些规则，我们使集合在维护其元素方面保持一致。 如果违反这些规则，则集合将表现出异常情况，例如找不到对象，或者返回错误的对象而不是正确的对象.
hashcode()和equal()联合实战
现在,让我们回到上面那个student例子,看看hashCode()和equals()方法如何影响Set的行为的
public class Student {
private String id;
private String name;
private String email;
private int age;
public Student(String id) {
this.id = id;
}
public Student(String id, String name, String email, int age) {
this.id = id;
this.name = name;
this.email = email;
this.age = age;
}
public String toString() {
String studentInfo = "Student " + id;
studentInfo += ": " + name;
studentInfo += " - " + email;
studentInfo += " - " + age;
return studentInfo;
}
public boolean equals(Object obj) {
if (obj instanceof Student) {
Student another = (Student) obj;
if (this.id.equals(another.id)) {
return true;
}
}
return false;
}
}
注意,到目前为止,只有equals()方法被覆盖。
我们将三个Student对象添加到HashSet中,如以下代码所示:
Student student1 = new Student("123", "Tom", "[email protected]", 30);
Student student2 = new Student("123", "Tom", "[email protected]", 30);
Student student3 = new Student("456", "Peter", "[email protected]", 23);
Set setStudents = new HashSet();
setStudents.add(student1);
setStudents.add(student2);
setStudents.add(student3);
现在，让我们使用Lambda表达式打印此集合中所有学生的信息:
setStudents.forEach(student -> System.out.println(student));
得到结果如下:
Student 456: Peter - [email protected] - 23
Student 123: Tom - [email protected] - 30
Student 123: Tom - [email protected] - 30
不知您是否注意到似乎有2个重复的学生(ID:123)
我们希望该集合包含不重复的元素,这为什么是可能的呢?(上面明明重复了啊)
原因在这里:
该集合对要添加的每个对象调用equals()和hashCode()方法,以确保没有重复.在我们的例子中,Student类仅覆盖equals()方法,
从Object类继承的hashCode()方法返回每个对象的内存地址,该地址与equals()方法不一致(这违反了上面的约定,如下图所示,这两个
对象所分配的地址就不一样).因此,该集合将student1和student2对象视为两个不同的元素。
现在，让我们重写Student类中的hashCode()方法，以遵守equals()和hashCode()的约定. 需要添加以下代码:
public int hashCode() {
return 31 + id.hashCode();
}
此方法基于id属性的哈希码返回整数(其hashCode()方法被String类覆盖).运行代码以再次打印集并观察结果：
Student 123: Tom - [email protected] - 30
Student 456: Peter - [email protected] - 23
调试验证
此时student1和student2的hashcode是相等的,故这里会调用equals()函数来判断两个对象是是否相等
hashcode方法():通过查看源码,我们这里可以知道:
其实hashcod的本质就是通过某种算法将传进来的对象映射为一个随机数(如果两个对象的属性是一样的,其哈希码肯定一样!!!)
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; }
在正确地覆盖了equals()和hashCode()方法之后，我们还可以像这样对集合执行搜索:
Student searchStudent = new Student("456");
boolean found = setStudents.contains(searchStudent);
System.out.println("Found student: " + found);
结果:
Found student: true
总结
请记住以下几点:
equals()方法比较两个对象在语义上是否相等，例如 比较类的数据成员。
hashCode()方法返回一个整数值，该整数值用于在基于哈希表的集合的存储桶中分配元素。
并记住equals()和hashCode()方法之间的约定：
当equals()方法被覆盖时,hashCode()方法也必须被覆盖。
如果两个对象相等,则它们的哈希码也必须相等。
如果两个对象不相等,则它们的哈希码没有限制（它们的哈希码可以相等或不相等）。
如果两个对象具有相同的哈希码,则它们的相等性不受限制（它们可以相等或不相等）。
如果两个对象具有不同的哈希码,则它们不能相等。
本文正在参加“写编程博客瓜分千元现金”活动,关注公众号“饥人谷”回复“编程博客”参与活动