Java에서 equals 메소드를 올바르게 재정의하는 방법

1. 동등 방법이란 무엇입니까?

먼저 객체 클래스가 Java, 즉 의 모든 클래스의 상위 클래스(슈퍼 클래스/기본 클래스)라는 것을 알아야 합니다. Java code>에서는 모든 클래스가 기본적으로 Object 클래스를 상속받습니다. 즉, Object 클래스에 구현된 모든 메소드를 직접 사용할 수 있습니다. 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

  다음 스크린샷은 Java11 API🎜🎜🎜🎜Object 클래스의 모든 메서드: 🎜🎜🎜

  1.1 같음 메서드:

  • 🎜같음code>: 예 <code>Object 클래스의 메서드는 참조 유형만 결정할 수 있습니다. 나중에 jdk 소스 코드를 보여드릴 수 있습니다🎜
  • 🎜기본적으로 , 주소가 Equality인지 여부를 결정합니다(참조 유형 변수의 기본 본질은 C/C++ 지식이 있는 친구가 매우 잘 알아야 하는 객체 주소를 저장하는 것이기 때문에). 이 메서드는 종종 하위 클래스에서 재정의되어 내용이 객체는 동일합니다. 예를 들어 Integer 및 String에 대해 간략하게 알아봅니다(IDEA의 소스 코드 구현 참조)🎜
  🎜2. 방법과 동일합니까? 🎜🎜Object 클래스에 구현된 equals 메서드를 사용할 수 있나요? 왜 equals 메서드를 재정의해야 합니까? 이는 Object 클래스의 equals 메서드 구현 메커니즘에 따라 다릅니다. 🎜🎜🎜🎜우리는 할 수 있습니다 이해 Object 클래스의 equals 메소드는 하단에 ==를 사용하여 구현된 것을 명확하게 볼 수 있는데, 이는 그 사용법이 우리가 일반적으로 사용하는 ==와 동일하다는 것을 의미합니다. 기본 데이터 유형을 비교하는 데 사용됩니다. 먼저 ==의 구문을 살펴보겠습니다. 🎜
  • 🎜==는 기본 데이터 유형의 동등성을 비교하는 데만 사용할 수 있습니다. 이는 간단한 값 비교입니다. 🎜 li>
  • 🎜== 부동 소수점 숫자를 비교할 때 오류가 발생할 수도 있습니다. 이는 부동 소수점 숫자의 저장 메커니즘이 정수 계열의 메커니즘과 다르기 때문입니다. 값 (구체적인 이유는 IEEE 754 규칙을 직접 확인하세요. 자세한 내용은 여기에 없습니다) 🎜
  🎜그래서 기본 데이터 유형의 값을 단순히 비교할 때 ==를 사용할 수 있지만 그렇게 할 수는 없습니다. 위에서 언급한 것처럼 참조 데이터 유형을 비교할 때 이렇게 하십시오. 참조 데이터 유형은 본질적으로 객체의 주소를 참조/저장하는 데 사용되므로 C/C++의 포인터로 처리할 수 있다고 언급했습니다. code> (여기서 Java에는 포인터가 없다고 합니다. 개인적으로는 이름이 다를 뿐이라고 생각합니다.)
  참고: Java 참조와 C++ 참조는 실제로 포인터 상수, 즉 <code> int* const이므로 C++의 참조는 별칭으로만 사용할 수 있습니다. 변수. 🎜

  2.1 예를 들어보겠습니다~

  🎜 두 정수를 비교할 때 ==를 직접 사용할 수 있습니다. 같으면 결과는 true이고, new이면 결과는 다음과 같습니다. 정확히 동일한 속성을 가진 두 개체를 얻은 경우 ==를 비교에 사용하면 오류가 발생합니다. 보시다시피 true , 결과는 <code>false
  소스 코드: 🎜🎜🎜🎜실행 결과: 🎜🎜🎜🎜이 시점에서 우리는 equals 메소드를 재정의해야 하는 이유에 대해 대략적으로 이해해야 합니다. 객체 비교, 우리에게 제공한 객체 클래스 코드>가 작동하지 않기 때문입니다~~🎜🎜3. 같음 소스 코드 분석: 🎜🎜다시 작성하기 전에 여전히 정의를 살펴보겠습니다. Java API:
  public boolean equals(Object obj)
  기능: 다른 개체가 이 개체와 "동일"한지 여부를 나타냅니다. 🎜🎜equals 메소드는 null이 아닌 객체 참조에 대한 동등성을 구현합니다: 🎜
  • 🎜재귀성: null이 아닌 참조 값 x , x.equals(x)는 true를 반환해야 합니다. 🎜
  • 🎜대칭: null이 아닌 참조 값 ​​x 및 y의 경우 x.equals(y)는 y.equals(x)가 true를 반환하는 경우에만 true를 반환해야 합니다. 🎜
  • 🎜전이성: null이 아닌 참조 값 ​​x, y 및 z의 경우, x .equals(y)는 true를 반환합니다. y.equals(z)는 true를 반환한 다음 x.equals를 반환합니다. ( z)는 true를 반환해야 합니다. 🎜

  • 일관성: null이 아닌 참조 값 ​​x 및 y의 경우 x.equals(y)를 여러 번 호출하면 항상 반환됩니다. true이거나 객체에 대한 equals 비교에 사용된 정보가 수정되지 않은 경우 항상 false를 반환합니다. 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源代码：
  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());
      }
  }

  具体实现思路在代码中讲的很清楚了，我们这里重点分析一下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

  null이 아닌 참조 값 x의 경우 x.equals(null)는 false를 반환해야 합니다.

  🎜

🎜Object 클래스의 equals 메소드는 객체에 대해 가장 구별 가능한 동등 관계를 구현합니다. 즉, x와 y가 동일한 참조 값을 갖는 경우에만 null이 아닌 참조 값인 x와 y에 대해 구현합니다. object( 이 메서드는 x == y 값이 true인 경우 true를 반환합니다.) 🎜🎜참고: 동일한 개체에는 동일한 해시 코드가 있어야 한다는 hashCode 메서드의 일반 계약을 유지하려면 일반적으로 이 메서드를 재정의할 때 hashCode 메서드를 재정의해야 합니다. 🎜🎜🎜🎜다음 보기 String 클래스에서 재정의된 equals 메서드와 Integer 클래스에서 재정의된 equals 메서드를 살펴보세요. 🎜🎜 🎜rrreee🎜간단한 설명 동일한 객체를 비교할 때 true를 직접 반환하면 효율성이 향상됩니다. 전달된 객체가 현재 클래스의 인스턴스인 경우 추가 판단이 입력됩니다. for 루프는 문자열의 각 문자를 차례로 순회합니다. 한 문자가 다르면 false가 반환됩니다. 🎜🎜계속해서 <code>Integer 클래스의 equals 소스 코드를 살펴보세요: 🎜🎜🎜rrreee🎜Integer 클래스의 equals 소스 코드는 훨씬 간단합니다. 객체가 현재 클래스의 인스턴스인 경우 추가 판단이 내려집니다. 해당 값이 동일하면 true가 반환되고, 동일하지 않으면 true가 반환됩니다. 동일하면 false가 반환됩니다. 🎜🎜다음은 Integer 클래스를 예로 들어 실제 데모 입니다. 🎜🎜🎜🎜분명히 우리는 Integer 클래스가 equals 메서드를 재정의하고 참조 유형. ==를 사용하여 참조 유형 변수를 직접 비교하면 결과는 false이고, equals를 사용하여 결과가 true인지 확인하는 경우입니다. 이는 equals 메서드를 재정의해야 한다는 점을 잘 보여줍니다. 문자열 클래스를 직접 확인해 보세요. ???? 기본적으로 equals 메소드의 다양한 소스 코드를 분석한 후 다음 단계는 equals 메소드를 직접 구현하는 것입니다. 🎜🎜다음은 두 가지 일반적인 equals 재작성 방법입니다. 🎜

🎜🎜 instanceof를 사용하여 equals 코드> 재작성을 구현하세요. code> 메서드🎜🎜🎜🎜<code>getClass를 사용하여 equals 메서드 재정의를 구현하세요🎜🎜

🎜다음 시나리오가 있다고 가정해 보세요. 🎜🎜생성된 후 재정의 직사각형 클래스의 Object 클래스에 있는 equals 메소드는 직사각형의 길이와 너비가 같을 때 TRUE를 반환하고 이를 다시 작성합니다. 동시에 hashCode 메서드를 사용하여 toString 메서드를 재정의하여 직사각형의 길이 및 너비 정보를 표시합니다. 그리고 수업을 테스트해 보세요. 🎜rrreee🎜구체적인 구현 아이디어는 코드에 명확하게 설명되어 있습니다. 여기서는 getClass 및 instanceof 두 가지 구현 방법의 장점과 단점을 분석하는 데 중점을 둡니다. 🎜🎜🎜🎜코드 로직 단순화:이 간단한 코드에 집중해 보겠습니다🎜rrreeerrreee🎜사실 두 솔루션 모두 유효합니다. 차이점은 getClass()가 객체를 동일한 클래스로만 제한하는 반면 인스턴스of code>는 객체가 동일한 클래스이거나 그 하위 클래스가 될 수 있도록 함으로써, equals 메소드가 부모 클래스가 되고, 하위 클래스도 동일 연산을 수행할 수 있도록 해준다. 이때, 하위 클래스가 equals 메소드를 재정의하면 가능해진다. 아래와 같이 상위 클래스 객체는 하위 클래스 객체와 동일하지만 하위 클래스 객체는 상위 클래스 객체와 동일하며 false입니다.🎜rrreee🎜여기에서는 <code>getClass()가 사용된다는 점에 유의하세요🎜🎜 🎜🎜반환값은 둘 다입니다. false, 이는 우리의 기대와 일치합니다(클래스도 다르기 때문에 false여야 함) 🎜🎜🎜🎜instanceof로 바꾸고 시도해 보세요: 🎜 🎜🎜 🎜

실행 결과: 하나는 true이고 다른 하나는 false입니다. 문제가 있는 것이 분명합니다. true一个为false，很明显出现问题了。

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

在重写equals方法的同时需要重写hashCode

🎜🎜이유 여기 다음과 같습니다.
instanceof의 구문은 다음과 같습니다.
객체가 클래스의 인스턴스인 경우 결과는 true입니다. 그러나 이 객체가 하위 클래스의 인스턴스인 경우 결과도 true라는 특성도 있습니다. 이로 인해 위의 버그가 발생합니다. 즉, 비교되는 두 개체가 부모-자식 관계에 있을 때 instanceof가 문제를 일으킬 수 있습니다. **더 공부해야 하는 친구는 스스로 배울 수 있으므로 equals 메소드를 다시 작성할 때 getClass를 사용하여 구현해 보는 것이 좋습니다. 🎜🎜equals 메서드를 재정의하는 경우 hashCode 메서드를 재정의해야 합니다. 🎜

위 내용은 Java에서 equals 메소드를 올바르게 재정의하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!