Tutorial zur Verwendung der Methode equal(), um in Java festzustellen, ob Objekte gleich sind

Die Methode equal in der Object-Klasse wird verwendet, um zu erkennen, ob ein Objekt einem anderen Objekt gleich ist. In der Object-Klasse ermittelt diese Methode, ob zwei Objekte dieselbe Referenz haben. Wenn zwei Objekte dieselbe Referenz haben, müssen sie gleich sein. Aus dieser Sicht ist es sinnvoll, dies zur Standardaktion zu machen. Für die meisten Klassen ist dieses Urteil jedoch nicht sinnvoll. Beispielsweise ist es völlig sinnlos, zwei PrintStreams auf diese Weise zu vergleichen. Allerdings ist es oft notwendig, die Gleichheit der Zustände zweier Objekte zu erkennen. Wenn die Zustände zweier Objekte gleich sind, werden die beiden Objekte als gleich betrachtet. Daher muss der Gleichheitsvergleich in benutzerdefinierten Klassen überschrieben werden.

Im Folgenden finden Sie Vorschläge zum Schreiben einer perfekten equal()-Methode:

(1) Der explizite Parameter heißt otherObject und muss später in eine Variable namens other umgewandelt werden

(2) Überprüfen Sie, ob this und otherObject auf dasselbe Objekt verweisen:

if(this==otherObject) return true;

Diese Anweisung ist nur eine Optimierung. Tatsächlich ist dies eine Form, die oft verwendet wird. Denn die Berechnung dieser Gleichung ist viel kostengünstiger als der einzelne Vergleich der Felder in der Klasse.

(3) Überprüfen Sie, ob otherObject null ist. Wenn es null ist, geben Sie false zurück. Dieser Test ist sehr notwendig.

if(otherObject==null) return false;

(4) Vergleichen Sie, ob dieses und otherObject zur gleichen Klasse gehören. Wenn sich die Semantik von equal in jeder Unterklasse ändert, verwenden Sie getClass(), um es zu erkennen Zielklasse

if(getClass()!=otherObject.getClass()) return false;

Wenn alle Unterklassen die gleiche Semantik haben, verwenden Sie zum Erkennen die Instanz von

if(!(otherObject instanceof ClassName)) return false;

( 5) Konvertieren Sie otherObject in eine Variable des entsprechenden Typs:

ClassName other=(ClassName)otherObject;

(6) Beginnen Sie nun mit dem Vergleich aller Felder, die verglichen werden müssen. Verwenden Sie ==, um Basistypfelder zu vergleichen, und equal, um Objektfelder zu vergleichen. Wenn alle Felder übereinstimmen, wird „true“ zurückgegeben, andernfalls wird „false“ zurückgegeben.

return field1==other.field1&&field2.equals(other.field2)

Wenn „equals“ in einer Unterklasse neu definiert wird, muss dies den Aufruf von „super.equals(other)“ umfassen. Wenn der Test fehlschlägt, ist Gleichheit unmöglich. Wenn die Felder in der Oberklasse gleich sind, werden die Instanzfelder in der Unterklasse verglichen.

Für Felder vom Typ Array können Sie die statische Methode Arrays.equals verwenden, um zu überprüfen, ob die entsprechenden Elemente gleich sind.

Sehen wir uns ein paar Beispiele für den String-Vergleich an:

String a = "abc";
String b = "abc";
String c = new String("abc");
String d = new String("abc");
System.out.println(a == b); // true 因为JAVA中字符串常量是共享的，只有一个拷贝
System.out.println(a == c); // false a和c属于2个不同的对象
System.out.println(a.equals(c)); // true 由于String对象的equals方法比较的是对象中的值，所以返回true。(和Object的equals方法不同)
System.out.println(c==d); // false c和d虽然对象内的值相同，但属于2个不同的对象，所以不相等
System.out.println(c.equals(d)); // true

Einfach ausgedrückt: Beim Vergleich von String-Konstanten liefert „equals“ das gleiche Ergebnis wie „equals“, wenn Sie „equals“ verwenden Ich möchte die Werte von String-Objekten vergleichen.

Sehen Sie sich ein Beispiel für die Verwendung von Gleichheit an:

package chapter05.EqualsTest;
  
import java.util.*;
  
public class EqualsTest {
 public static void main(String[] args) {
  Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
  Employee alice2 = alice1; // reference the same object
  Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
  Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);
  
  System.out.println("alice1 == alice2: " + (alice1 == alice2));
  
  System.out.println("alice1 == alice3: " + (alice1 == alice3));
  
  System.out.println("alice1.equals(alice3): " + (alice1.equals(alice3)));
  
  System.out.println("alice1.equals(bob): " + (alice1.equals(bob)));
  
  System.out.println(bob.toString());
 }
}
  
class Employee {
 public Employee(String n, double s, int year, int month, int day) {
  name = n;
  salary = s;
  GregorianCalendar calendar = new GregorianCalendar(year, month, day);
  hireDay = calendar.getTime();
 }
  
 public String getName() {
  return name;
 }
  
 public double getSalary() {
  return salary;
 }
  
 public Date getHireDay() {
  return hireDay;
 }
  
 public void raiseSalary(double byPercent) {
  double raise = salary * byPercent / 100;
  salary += raise;
 }
  
 @Override
 public boolean equals(Object otherObject) {
  // a quick test to see if the objects are identical
  if (this == otherObject)
   return true;
  
  // must return false if the explicit parameter is null
  if (otherObject == null)
   return false;
  
  // if the classed don't match,they can't be equal
  if (getClass() != otherObject.getClass())
   return false;
  
  // now we know otherObject is a non-null Employee
  Employee other = (Employee) otherObject;
  
  // test whether the fields hava identical values
  return name.equals(other.name) && salary == other.salary
    && hireDay.equals(other.hireDay);
  
 }
  
 @Override
 public int hashCode() {
  return 7 * name.hashCode() + 11 * new Double(salary).hashCode() + 13
    * hireDay.hashCode();
 }
  
 @Override
 public String toString() {
  return getClass().getName() + "[name=" + name + ",salary=" + salary
    + ",hireDay=" + hireDay + "]";
 }
  
 private String name;
 private double salary;
 private Date hireDay;
}
  
class Manager extends Employee {
 public Manager(String n, double s, int year, int month, int day) {
  super(n, s, year, month, day);
  bouns = 0;
 }
  
 @Override
 public double getSalary() {
  double baseSalary = super.getSalary();
  return baseSalary + bouns;
 }
  
 public void setBouns(double b) {
  bouns = b;
 }
  
 @Override
 public boolean equals(Object otherObject) {
  if (!super.equals(otherObject))
   return false;
  Manager other = (Manager) otherObject;
  // super equals checked that this and other belong to the same class
  return bouns == other.bouns;
 }
  
 @Override
 public int hashCode() {
  return super.hashCode() + 17 * new Double(bouns).hashCode();
 }
  
 @Override
 public String toString() {
  return super.toString() + "[bouns=" + bouns + "]";
 }
  
 private double bouns;
}

Gehen Sie tiefer
Das Folgende ist in zwei Kategorien unterteilt, je nachdem, ob die Klasse Gleichheit abdeckt ()-Methode" .
(1) Wenn eine Klasse die Methode equal() nicht abdeckt, vergleicht sie beim Vergleich zweier Objekte über equal() tatsächlich, ob die beiden Objekte dasselbe Objekt sind. Zu diesem Zeitpunkt entspricht dies dem Vergleich der beiden Objekte über „==“.
(2) Wir können die Methode equal() der Klasse überschreiben, damit equal() mit anderen Methoden vergleichen kann, ob zwei Objekte gleich sind. Der übliche Ansatz ist: Wenn die Inhalte der beiden Objekte gleich sind, gibt die Methode equal() true zurück, andernfalls gibt sie fasle zurück.
Das Folgende ist ein Beispiel, um die beiden oben genannten Situationen zu veranschaulichen.
1. „Die Methode equal() wird nicht abgedeckt“
Der Code lautet wie folgt (EqualsTest1.java):

import java.util.*;
import java.lang.Comparable;
 
/**
 * @desc equals()的测试程序。
 
 */
public class EqualsTest1{
 
 public static void main(String[] args) {
  // 新建2个相同内容的Person对象，
  // 再用equals比较它们是否相等
  Person p1 = new Person("eee", 100);
  Person p2 = new Person("eee", 100);
  System.out.printf("%s\n", p1.equals(p2));
 }
 
 /**
  * @desc Person类。
  */
 private static class Person {
  int age;
  String name;
 
  public Person(String name, int age) {
   this.name = name;
   this.age = age;
  }
 
  public String toString() {
   return name + " - " +age;
  }
 }
}

Laufendes Ergebnis:

false

Ergebnisanalyse
Wir verwenden p1.equals(p2), um „zu vergleichen, ob p1 und p2 gleich sind“. Tatsächlich wird die Methode equal() von Object.java aufgerufen, dh (p1==p2). Es vergleicht, „ob p1 und p2 dasselbe Objekt sind“.
Aus den Definitionen von p1 und p2 wissen wir, dass sie zwar denselben Inhalt haben, aber zwei verschiedene Objekte sind! Daher ist das Rückgabeergebnis falsch.

2. Der Fall „Überschreiben der Methode equal()“
Wir ändern das obige EqualsTest1.java: Überschreiben Sie die Methode equal().
Der Code lautet wie folgt (EqualsTest2.java):

import java.util.*;
import java.lang.Comparable;
 
/**
 * @desc equals()的测试程序。
 */
public class EqualsTest2{
 
 public static void main(String[] args) {
  // 新建2个相同内容的Person对象，
  // 再用equals比较它们是否相等
  Person p1 = new Person("eee", 100);
  Person p2 = new Person("eee", 100);
  System.out.printf("%s\n", p1.equals(p2));
 }
 
 /**
  * @desc Person类。
  */
 private static class Person {
  int age;
  String name;
 
  public Person(String name, int age) {
   this.name = name;
   this.age = age;
  }
 
  public String toString() {
   return name + " - " +age;
  }
 
  /**
   * @desc 覆盖equals方法
   */
  @Override
  public boolean equals(Object obj){
   if(obj == null){
    return false;
   }
 
   //如果是同一个对象返回true，反之返回false
   if(this == obj){
    return true;
   }
 
   //判断是否类型相同
   if(this.getClass() != obj.getClass()){
    return false;
   }
 
   Person person = (Person)obj;
   return name.equals(person.name) && age==person.age;
  }
 }
}

Laufende Ergebnisse:

true

Ergebnisanalyse:
Wir sind dabei EqualsTest2.java Die Funktion equal() von Person wurde neu geschrieben: Wenn Name und Alter zweier Person-Objekte gleich sind, wird true zurückgegeben.
Daher gibt das laufende Ergebnis „true“ zurück.
Apropos, lassen Sie uns übrigens über Javas Anforderungen für equal() sprechen. Es gibt folgende Punkte:
Symmetrie: Wenn x.equals(y) „wahr“ zurückgibt, dann sollte y.equals(x) auch „wahr“ zurückgeben.
Reflektierend: x.equals(x) muss „true“ zurückgeben.
Analogie: Wenn x.equals(y) „wahr“ zurückgibt und y.equals(z) „wahr“ zurückgibt, dann sollte z.equals(x) auch „wahr“ zurückgeben.
Konsistenz: Wenn x.equals(y) „wahr“ zurückgibt, ist die Rückgabe „wahr“, solange der Inhalt von x und y unverändert bleibt, unabhängig davon, wie oft Sie x.equals(y) wiederholen. .
Nicht-Leerheit, x.equals(null), gibt immer „false“ zurück; x.equals (ein Objekt eines anderen Typs als x) gibt immer „false“ zurück.
Lassen Sie uns nun die Rolle von equal() überprüfen: um zu bestimmen, ob zwei Objekte gleich sind. Wenn wir equal() umschreiben, dürfen wir seine Funktion nicht ändern!

equals() 与 == 的区别是什么？
== : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况(前面第1部分已详细介绍过)：
     情况1，类没有覆盖equals()方法。则通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象。
     情况2，类覆盖了equals()方法。一般，我们都覆盖equals()方法来两个对象的内容相等；若它们的内容相等，则返回true(即，认为这两个对象相等)。
下面，通过示例比较它们的区别。
代码如下：

import java.util.*;
import java.lang.Comparable;
 
/**
 * @desc equals()的测试程序。
 */
public class EqualsTest3{
 
 public static void main(String[] args) {
  // 新建2个相同内容的Person对象，
  // 再用equals比较它们是否相等
  Person p1 = new Person("eee", 100);
  Person p2 = new Person("eee", 100);
  System.out.printf("p1.equals(p2) : %s\n", p1.equals(p2));
  System.out.printf("p1==p2 : %s\n", p1==p2);
 }
 
 /**
  * @desc Person类。
  */
 private static class Person {
  int age;
  String name;
 
  public Person(String name, int age) {
   this.name = name;
   this.age = age;
  }
 
  public String toString() {
   return name + " - " +age;
  }
 
  /**
   * @desc 覆盖equals方法
   */
  @Override
  public boolean equals(Object obj){
   if(obj == null){
    return false;
   }
 
   //如果是同一个对象返回true，反之返回false
   if(this == obj){
    return true;
   }
 
   //判断是否类型相同
   if(this.getClass() != obj.getClass()){
    return false;
   }
 
   Person person = (Person)obj;
   return name.equals(person.name) && age==person.age;
  }
 }
}

运行结果：

p1.equals(p2) : true
p1==p2 : false

结果分析：
在EqualsTest3.java 中：
(1) p1.equals(p2)
这是判断p1和p2的内容是否相等。因为Person覆盖equals()方法，而这个equals()是用来判断p1和p2的内容是否相等，恰恰p1和p2的内容又相等；因此，返回true。
(2) p1==p2
这是判断p1和p2是否是同一个对象。由于它们是各自新建的两个Person对象；因此，返回false。

更多Java中判断对象是否相等的equals()方法使用教程相关文章请关注PHP中文网！