Java比较学习重写equals方法的安全写法

Posted 宁海没有七号公园

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java比较学习重写equals方法的安全写法相关的知识,希望对你有一定的参考价值。

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

正文开始@Assassin

1. 什么是equals方法?

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

以下截图自Java11 API

Object类的所有方法:

1.1 equals方法:

  • equals:是Object类中的方法,只能判断引用类型,等下可以带大伙看看jdk源码
  • 默认判断的是地址是否相等(因为引用类型变量底层本质就是来存储对象地址的,有C/C++知识的小伙伴应该很了解 ),在子类中往往会重写该方法,用于判断对象的内容是否相等。比如等下会简单了解到的IntegerString(在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对象引用上实现等价关系:

  • 自反性 :对于任何非空的参考值xx.equals(x)应该返回true
  • 对称性 :对于任何非空引用值xyx.equals(y)应该返回true当且仅当y.equals(x)回报true
  • 传递性 :对于任何非空引用值xyz ,如果x.equals(y)回报truey.equals(z)回报true ,然后x.equals(z)应该返回true
  • 一致性 :对于任何非空引用值xy ,多次调用x.equals(y)始终返回true或始终返回false ,前提是未修改对象上的equals比较中使用的信息。
  • 对于任何非空的参考值xx.equals(null)应该返回false

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

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


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

//String类equals源代码:
public 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方法为显示长方形的长宽信息。并测试类。

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());
    }
}

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

将代码逻辑简化一下:
我们就重点看这段简单的代码

//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方法,具体原因可能后续会讲到~~

以上是关于Java比较学习重写equals方法的安全写法的主要内容,如果未能解决你的问题,请参考以下文章

深入java的equals方法,怎么比较两个对象的

java equals比较的是内容还是地址

重写equals 方法的注意事项

Java,重写Comparable比较方法,重写equals方法, Long 与 Long equals,Long 与 Long == ,Long 与 long ==

Java,重写Comparable比较方法,重写equals方法, Long 与 Long equals,Long 与 Long == ,Long 与 long ==

Java,重写Comparable比较方法,重写equals方法, Long 与 Long equals,Long 与 Long == ,Long 与 long ==