Comment utiliser la méthode Java Equals()

En Java, la méthode equals() est utilisée pour détecter si un objet est égal à un autre objet, la syntaxe est "Object.equals(Object2)" ; cette méthode détermine si deux objets ont la même référence si les deux objets. ont les mêmes Références, elles doivent être égales. La méthode equals() ne peut pas fonctionner sur des variables de types de données de base.

L'environnement d'exploitation de ce tutoriel : système windows7, version java8, ordinateur DELL G3.

La méthode Java equals() détermine si les objets sont égaux

La méthode equals est utilisée pour détecter si un objet est égal à un autre objet. Remarque : La méthode equals ne peut pas agir sur les variables des types de données de base. Dans la classe Object, cette méthode détermine si deux objets ont la même référence. Si deux objets ont la même référence, ils doivent être égaux.

De ce point de vue, il est logique d’en faire l’opération par défaut. Cependant, pour la plupart des classes, ce jugement n'a pas de sens. Par exemple, comparer deux PrintStreams de cette manière n'a aucun sens. Or, il est souvent nécessaire de détecter l’égalité des états de deux objets. Si les états de deux objets sont égaux, les deux objets sont considérés comme égaux. Par conséquent, la comparaison égale doit être remplacée dans les classes personnalisées.

Ce qui suit sont des suggestions pour écrire une méthode equals() parfaite :

(1) Nommez le paramètre explicite otherObject, qui doit être converti en une variable appelée other plus tard

(2) Vérifiez si ceci et otherObject ont le même référence Un objet :

if(this==otherObject) return true;

Cette déclaration n'est qu'une optimisation. En fait, c’est une forme souvent adoptée. Parce que calculer cette équation coûte beaucoup moins cher que comparer les champs de la classe un par un.

(3) Vérifiez si otherObject est nul S'il est nul, renvoyez false. Ce test est très nécessaire.

if(otherObject==null) return false;

(4) Comparez ceci et otherObject pour voir s'ils appartiennent à la même classe. Si la sémantique des égaux change dans chaque sous-classe, utilisez getClass() pour le détecter et l'utiliser comme classe cible

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

Si toutes les sous-classes sont toutes. ont la même sémantique, utilisez instanceof pour détecter

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

(5) Convertissez otherObject en une variable du type correspondant :

ClassName other=(ClassName)otherObject;

(6) Commencez maintenant à comparer tous les champs qui doivent être comparés. Utilisez == pour comparer les champs de type de base et égal pour comparer les champs d'objet. Si tous les champs correspondent, renvoie true, sinon renvoie false

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

Si equals est redéfini dans une sous-classe, cela doit inclure l'appel de super.equals(other). Si le test échoue, l’égalité est impossible. Si les champs de la superclasse sont égaux, les champs d'instance de la sous-classe sont comparés.

Pour les champs de type tableau, vous pouvez utiliser la méthode statique Arrays.equals pour vérifier si les éléments correspondants sont égaux.

Regardons quelques exemples de comparaison de chaînes :

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

En termes simples, lorsque vous comparez des constantes de chaîne, égal renvoie le même résultat que égal à. Utilisez égal lorsque vous souhaitez comparer les valeurs des objets chaîne.

Regardez un exemple d'utilisation d'égal à égal :

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

Quelle est la différence entre égal à() et == ?

== : Sa fonction est de déterminer si les adresses de deux objets sont égales. Autrement dit, déterminez si deux objets sont le même objet.

equals() : Sa fonction est également de déterminer si deux objets sont égaux. Mais elle a généralement deux cas d'utilisation :

Cas 1, la classe ne couvre pas la méthode equals(). Ensuite, comparer deux objets de cette classe via equals() équivaut à comparer les deux objets via "==".

• Cas 2, la classe couvre la méthode equals(). Généralement, nous remplaçons la méthode equals() pour garantir que les contenus des deux objets sont égaux ; si leurs contenus sont égaux, true est renvoyé (c'est-à-dire que les deux objets sont considérés comme égaux).

• Ci-dessous, comparez leurs différences à travers des exemples.

Le code est le suivant :

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

Résultats d'exécution :

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

Analyse des résultats :

Dans EqualsTest3.java :

(1) p1.equals(p2)

Il s'agit de déterminer si les contenus de p1 et p2 sont égaux. Étant donné que Person remplace la méthode equals() et que cette méthode equals() est utilisée pour déterminer si les contenus de p1 et p2 sont égaux, il arrive que les contenus de p1 et p2 soient égaux, donc true est renvoyé ;

• p1.equals(p2)
  这是判断p1和p2的内容是否相等。因为Person覆盖equals()方法，而这个equals()是用来判断p1和p2的内容是否相等，恰恰p1和p2的内容又相等；因此，返回true。

• (2) p1==p2
  (2) p1==p2

  Il s'agit de déterminer si p1 et p2 sont le même objet. Puisqu'il s'agit respectivement de deux objets Person nouvellement créés, false est renvoyé.

Pour plus de connaissances liées à la programmation, veuillez visiter : Enseignement de la programmation

 ! ! 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!