Java中如何正确重写equals方法

Java中如何正确重写equals方法

目录1. 什么是equals方法？1.1 equals方法：2. 为什么要重写equals方法？2.1 举个例子吧~3. 分析equals源码：4. 正确重写equals方法：

重写equals方法的正确打开方式

正文开始@Assassin

1. 什么是equals方法？

我们首先得知道，Object类是 java中所有类的父类(超类/基类)，也就是说，在Java中，所有的类都是默认继承自Object类的，换言之，Object类中所实现的方法我们都可以直接拿来用。而equals方法便是Object类所实现的众多方法之一。

以下截图自Java11 API

Object类的所有方法：

1.1 equals方法：

equals：是Object类中的方法，只能判断引用类型，等下可以带大伙看看jdk源码

默认判断的是地址是否相等（因为引用类型变量底层本质就是来存储对象地址的，有C/C++知识的小伙伴应该很了解 ），在子类中往往会重写该方法，用于判断对象的内容是否相等。比如等下会简单了解到的Integer和String(在IDEA里看源码实现 )

2. 为什么要重写equals方法？

我们有Object类实现的equals方法能用不就行了？为啥还得重写equals方法呢？这就要看看Object类的equals方法实现机制了。

我们可以清楚地看到，Object类的equals方法底层是用 == 来实现的，也就是说它的用法跟我们平常用来比较基本数据类型的 == 用法一致。我们首先来看一下 == 的语法：

== 只能用来比较基本数据类型是否相等，也就是单纯的值比较；

== 在比较浮点数的时候也可能存在失效的情况，这是因为浮点数的存储机制跟整型家族不一样，浮点数本身就不能表示一个精确的值（具体原因可自行查看IEEE 754规则，这里不再展开）

所以我们在单纯的进行基本数据类型的值比较时可以用 == ，而比较引用数据类型就不能这么做，前面有提到，引用数据类型本质上是来引用/存储对象的地址的，所有你完全可以把它当做C/C++的指针来看待（这里杠一句说Java没有指针的，个人觉得只是叫法不同罢了 ）

注： 不要把Java引用跟C++引用搞混了，C++引用其实是指针常量，即int* const，这也是C++的引用只能作为一个变量的别名的原因。

2.1 举个例子吧~

比较两个int时可以直接用 == ，当它们相等时结果为true，而当new了两个属性完全一样的对象时，再用 == 来进行比较就会出现错误，如我们所见，明明我们应该想要得到true的，结果却是false

源码：

运行结果：

到这里，我们应该大致清楚为啥要在比较对象时重写equals方法了，因为Object类提供给我们的不好使~~

3. 分析equals源码：

在进行重写之前，我们依旧来看看Java API中的定义：

public boolean equals​(Object obj)

作用：指示某个其他对象是否“等于”此对象。

equals方法在非null对象引用上实现等价关系：

自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。

对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。

传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后x.equals(z)应该返回true 。

一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息。

对于任何非空的参考值x ， x.equals(null)应该返回false。

类Object的equals方法实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当x和y引用同一对象（ x == y具有值true ）时，此方法返回true 。

注意：通常需要在重写此方法时覆盖hashCode方法，以便维护hashCode方法的常规协定，该方法声明相等对象必须具有相等的哈希代码。

接下来看看String类中重写的equals方法和Integer类中重写的equals方法：

//String类equals源代码：

pubBcHOOlic boolean equals(Object anObject) {

if (this == anObject) {

return true;

}

if (anObject instanceof String) {

String anotherString = (String)anObject;

int n = value.length;

if (n == anotherString.value.length) {

char v1[] = value;

char v2[] = anotherString.value;

int i = 0;

while (n-- != 0) {

if (v1[i] != v2[i])

return false;

i++;

}

return true;

}

}

return false;

}

简单解读一下就是当对比的是同一个对象时，直接返回true，提高效率。当传进来的对象是当前类的实例时，进入进一步的判断，一个for循环依次遍历字符串每一个字符，只要有一个字符不同就返回false。

继续来看看Integer类的equals源代码：

//Integer类的equals源代码:

public boolean equals(Object obj) {

if (obj instanceof Integer) {

return value == ((Integer)obj).intValue();

}

return false;

}

Integer类的equals源码简单许多，只要传入的对象是当前类的实例，就进行进一步的判断：当它们的值相等时，就返回true，不相等就返回false。

这里还是来实际演示一下⑧，就以Integer类为例：

很明显，我们知道Integer类重写了equals方法且是引用类型。当直接用 == 来比较引用类型变量时，结果是false，而用equals判断结果为true。这便很好地说明了重写equals方法的必要性。String类大伙自己验证一哈⑧。

4. 正确重写equals方法：

（先说结论，getClass()比instanceof更安全）

到这里，我们基本把equals方法的各种源码都分析了一遍，接下来就是我们自己要来实现equals方法了。

这里提供两个比较常见的equals重写方法：

用instanceof实现重写equals方法

用getClass实现重写equals方法

假设有此场景：

在已经创建好的长方形类中重写Object类中的equals方法为当长方形的长和宽相等时，返回TRUE，同时重写hashCode方法，重写toString方法为显http://示长方形的长宽信息。并测试类。

package com.test10_04;

import java.util.Objects;

class Rectangle {

private double length;

private double wide;

public Rectangle() {

//空实现

}

public Rectangle(double length, double wide) {

setLength(length);

setWide(wide);

}

public double getLength() {

return length;

}

public void setLength(double length) {

assert length > 0.0 : "您的输入有误，长方形的长不能小于0";

this.length = length;

}

public double getWide() {

return wide;

}

public void setWide(double wide) {

assert wide > 0.0 : "您的输入有误，长方形的宽不能小于0";

this.wide = wide;

}

public double area() {

return this.length * this.wide;

}

public double circumference() {

return 2 * (this.wide + this.length);

}

public boolean equals(Object obj) {

if (this == obj) { //判断一下如果是同一个对象直接返回true，提高效率

return true;

}

if (obj == null || obj.getClass() != this.getClass()) { //如果传进来的对象为null或者二者为不同类，直接返回false

return false;

}

//也可以以下方法：

// if (obj == null || !(obj instanceof Rectangle)) { //如果传进来的对象为null或者二者为不同类，直接返回false

// return false;

// }

Rectangle rectangle = (Rectangle) obj; //向下转型

//比较长宽是否相等，注意：浮点数的比较不能简单地用==，会有精度的误差，用Math.abs或者Double.compare

return Double.compare(rectangle.length, length) == 0 && Double.compare(rectangle.wide, wide) == 0;

}

public int hashCode() { //重写equals的同时也要重写hashCode，因为同一对象的hashCode永远相等

return Objects.hash(length, wide); //调用Objects类，这是Object类的子类

}

public String toString() {

return "Rectangle{" + "length=" + length + ", wide=" + wide + '}';

}

}

public class TestDemo {

public static void main(String[] args) {

Rectangle rectangle1 = new Rectangle(3.0, 2.0);

Rectangle rectangle2 = new Rectangle(3.0, 2.0);

System.out.println(rectangle1.equals(rectangle2));

System.out.println("rectangle1哈希码:" + rectangle1.hashCode() +

"\nrectangle2哈希码:" + rectangle2.hashCode());

System.out.println("toString打印信息：" + rectangle1.toString());

}

}

具体实现思路在代码中讲的很清楚了，我们这里重点分析一下getClass和instanceof两种实现方法的优缺点：

将代码逻辑简化一下：

我们就重点看这段简单的代码

//getClass()版本

public class Student {

private String name;

public void setName(String name) {

this.name = name;

}

@Override

public boolean equals(Object object){

if (object == this)

return true;

// 使用getClass()判断对象是否属于该类

if (object == null || object.getClass() != getClass())

return false;

Student student = (Student)object;

return name != null && name.equals(student.name);

}

//instanceof版本

public class Student {

private String name;

public void setName(String name) {

this.name = name;

}

@Override

public boolean equals(Object object){

if (object == this)

return true;

// 通过instanceof来判断对象是否属于类

if (object == null || !(object instanceof Student))

return false;

Student student = (Student)object;

return name!=null && name.equals(student.name);

}

}

事实上两种方案都是有效的，区别就是getClass()限制了对象只能是同一个类，而instanceof却允许对象是同一个类或其子类，这样equals方法就变成了父类与子类也可进行equals操作了，这时候如果子类重定义了equals方法，那么就可能变成父类对象equlas子类对象为true，但是子类对象equlas父类对象就为false了，如下所示:

class GoodStudent extends Student {

@Override

public boolean equals(Object object) {

return false;

}

public static void main(String[] args) {

GoodStudent son = new GoodStudent();

Student father = new Student();

son.setName("test");

father.setName("test");

// 当使用instance of时

System.out.println(son.equals(father)); // 这里为false

System.out.println(father.equals(son)); // 这里为true

// 当使用getClass()时

System.out.println(son.equals(father)); // 这里为false

System.out.println(father.equals(son)); // 这里为false

}

}

注意看这里用的是getClass()

返回值两个都是false，符合我们的预期，（连类都不一样那肯定得为false啊）

而换成instanceof试试看咯：

运行结果：一个为true一个为false，很明显出现问题了。

这里的原因如下：

instanceof的语法是这样的：

当一个对象为一个类的实例时，结果才为true。但它还有一个特点就是，如果当这个对象时其子类的实例时，结果也会为true。这便导致了上述的bug。也就是说当比较的两个对象，他们的类是父子关系时，instanceof可能会出现问题。**需要深究的小伙伴可以自己去了解一哈，所以在这里建议在实现重写equals方法时，尽量使用getClass来实现。

在重写equals方法的同时需要重写hashCode方法，具体原因可能后续会讲到~~

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。