Quelle est la différence entre == et equals () en Java?

Je voulais clarifier si je comprends bien:

• == est une comparaison de référence, c.-à-d. que les deux objets pointent vers le même emplacement mémoire
• .equals() évalue à la comparaison des valeurs dans les objets

En général, la réponse à votre question est "oui", mais ...

• .equals(...) ne fera que comparer ce qu'il est écrit pour comparer, ni plus, ni moins.
• Si une classe ne remplace pas la méthode equals, elle utilise par défaut la equals(Object o)méthode de la classe parent la plus proche qui a remplacé cette méthode.
• Si aucune classe parent n'a fourni de substitution, la méthode par défaut est la classe parent ultime, Object, et vous vous retrouvez donc avec la Object#equals(Object o)méthode. Selon l'API Object, c'est la même chose que ==; c'est-à-dire qu'elle renvoie vrai si et seulement si les deux variables font référence au même objet, si leurs références sont identiques. Ainsi, vous testerez l'égalité des objets et non l'égalité fonctionnelle .
• N'oubliez pas de passer outre hashCodesi vous passez outre equalsafin de ne pas «rompre le contrat». Selon l'API, le résultat renvoyé par la hashCode()méthode pour deux objets doit être le même si leurs equalsméthodes montrent qu'elles sont équivalentes. L'inverse n'est pas nécessairement vrai.

En ce qui concerne la classe String:

La méthode equals () compare la "valeur" à l'intérieur des instances de String (sur le tas), que les deux références d'objet se réfèrent ou non à la même instance de String. Si deux références d'objet de type String font référence à la même instance de String, c'est parfait! Si les deux références d'objet font référence à deux instances de chaîne différentes .. cela ne fait aucune différence. C'est la "valeur" (c'est-à-dire le contenu du tableau de caractères) à l'intérieur de chaque instance de chaîne qui est comparée.

En revanche, l' opérateur "==" compare la valeur de deux références d'objet pour voir si elles se réfèrent à la même instance de chaîne . Si la valeur des deux références d'objet "fait référence à" la même instance de chaîne, le résultat de l'expression booléenne serait "vrai" .. duh. Si, d'autre part, la valeur des deux références d'objet "fait référence à" différentes instances de String (même si les deux instances de String ont des "valeurs" identiques, c'est-à-dire que le contenu des tableaux de caractères de chaque instance de String est le même), la le résultat de l'expression booléenne serait "faux".

Comme pour toute explication, laissez-la pénétrer.

J'espère que cela clarifie un peu les choses.

Il y a quelques petites différences selon que vous parlez de "primitives" ou de "types d'objets"; la même chose peut être dite si vous parlez de membres "statiques" ou "non statiques"; vous pouvez également mélanger tout ce qui précède ...

Voici un exemple (vous pouvez l'exécuter):

public final class MyEqualityTest
{
    public static void main( String args[] )
    {
        String s1 = new String( "Test" );
        String s2 = new String( "Test" );

        System.out.println( "\n1 - PRIMITIVES ");
        System.out.println( s1 == s2 ); // false
        System.out.println( s1.equals( s2 )); // true

        A a1 = new A();
        A a2 = new A();

        System.out.println( "\n2 - OBJECT TYPES / STATIC VARIABLE" );
        System.out.println( a1 == a2 ); // false
        System.out.println( a1.s == a2.s ); // true
        System.out.println( a1.s.equals( a2.s ) ); // true

        B b1 = new B();
        B b2 = new B();

        System.out.println( "\n3 - OBJECT TYPES / NON-STATIC VARIABLE" );
        System.out.println( b1 == b2 ); // false
        System.out.println( b1.getS() == b2.getS() ); // false
        System.out.println( b1.getS().equals( b2.getS() ) ); // true
    }
}

final class A
{
    // static
    public static String s;
    A()
    {
        this.s = new String( "aTest" );
    }
}

final class B
{
    private String s;
    B()
    {
        this.s = new String( "aTest" );
    }

    public String getS()
    {
        return s;
    }

}

Vous pouvez comparer les explications de "==" (Opérateur d'égalité) et ".equals (...)" (méthode dans la classe java.lang.Object) via ces liens:

• ==: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
• .equals (...): http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)

La différence entre == et égal m'a confondu pendant un certain temps jusqu'à ce que je décide de l'examiner de plus près. Beaucoup d'entre eux disent que pour comparer une chaîne, vous devez utiliser equalset non ==. J'espère que dans cette réponse je pourrai faire la différence.

La meilleure façon de répondre à cette question sera de vous poser quelques questions. Commençons donc:

Quelle est la sortie pour le programme ci-dessous:

String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);

si tu le dis,

false
true

Je dirai que vous avez raison, mais pourquoi avez-vous dit cela ? et si vous dites que la sortie est,

true
false

Je dirai que vous vous trompez mais je vous demanderai toujours pourquoi vous pensez que c'est vrai?

Ok, essayons de répondre à celui-ci:

Quelle est la sortie pour le programme ci-dessous:

String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);

Maintenant, si vous dites,

false
true

Je dirai que tu as tort mais pourquoi est-ce mal maintenant ? la sortie correcte pour ce programme est

true
false

Veuillez comparer le programme ci-dessus et essayer d'y penser.

D'accord. Maintenant, cela pourrait aider (veuillez lire ceci: imprimer l'adresse de l'objet - pas possible mais nous pouvons toujours l'utiliser.)

String mango = "mango";
String mango2 = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango2);
System.out.println(mango == mango2);
System.out.println(mango3 != mango2);
System.out.println(mango3 == mango2);
// mango2 = "mang";
System.out.println(mango+" "+ mango2);
System.out.println(mango != mango2);
System.out.println(mango == mango2);

System.out.println(System.identityHashCode(mango));
System.out.println(System.identityHashCode(mango2));
System.out.println(System.identityHashCode(mango3));

pouvez-vous juste essayer de penser à la sortie des trois dernières lignes dans le code ci-dessus: pour moi, ideone l'a imprimé ( vous pouvez vérifier le code ici ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Oh! Maintenant, vous voyez que l' identitéHashCode (mangue) est égale à l'identitéHashCode (mangue2) Mais ce n'est pas égal à l'identitéHashCode (mangue3)

Même si toutes les variables de chaîne - mango, mango2 et mango3 - ont la même valeur, qui est "mango", identityHashCode()n'est pas toujours la même pour tous.

Maintenant, essayez de décommenter cette ligne // mango2 = "mang";et de l'exécuter à nouveau cette fois, vous verrez que les trois identityHashCode()sont différents. Hmm c'est un indice utile

nous savons que si hashcode(x)=Net hashcode(y)=N=>x is equal to y

Je ne sais pas comment Java fonctionne en interne, mais je suppose que c'est ce qui s'est passé lorsque j'ai dit:

mango = "mango";

java a créé une chaîne "mango"qui a été pointée (référencée) par la variable mangoquelque chose comme ça

mango ----> "mango"

Maintenant dans la ligne suivante quand j'ai dit:

mango2 = "mango";

Il a en fait réutilisé la même chaîne "mango"qui ressemble à ceci

mango ----> "mango" <---- mango2

La mangue et mango2 pointent vers la même référence. Maintenant, quand j'ai dit

mango3 = new String("mango")

Il a en fait créé une toute nouvelle référence (chaîne) pour "mangue". qui ressemble à ceci,

mango -----> "mango" <------ mango2

mango3 ------> "mango"

et c'est pourquoi quand je mets les valeurs pour mango == mango2, ça mets true. et quand je mets la valeur pour mango3 == mango2, elle s'éteint false(même lorsque les valeurs sont les mêmes).

et lorsque vous avez commenté la ligne, // mango2 = "mang"; cela a en fait créé une chaîne "mang" qui a transformé notre graphique comme ceci:

mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"

C'est pourquoi le IdentityHashCode n'est pas le même pour tous.

J'espère que cela vous aide les gars. En fait, je voulais générer un cas de test où == échoue et equals () réussit. N'hésitez pas à commenter et à me faire savoir si je me trompe.

L' opérateur == teste si deux variables ont les mêmes références (aka pointeur vers une adresse mémoire) .

String foo = new String("abc");
String bar = new String("abc");

if(foo==bar)
// False (The objects are not the same)

bar = foo;

if(foo==bar)
// True (Now the objects are the same)

Alors que la méthode equals () teste si deux variables se réfèrent à des objets qui ont le même état (valeurs) .

String foo = new String("abc");
String bar = new String("abc");

if(foo.equals(bar))
// True (The objects are identical but not same)

À votre santé :-)

Vous devrez remplacer la fonction equals (ainsi que d'autres) pour l'utiliser avec des classes personnalisées.

La méthode equals compare les objets.

L' ==opérateur binaire compare les adresses mémoire.

== et .equals () font référence au même objet si vous ne remplacez pas .equals ().

C'est votre souhait ce que vous voulez faire une fois que vous remplacez .equals (). Vous pouvez comparer l'état de l'objet appelant avec l'état de l'objet passé ou vous pouvez simplement appeler super.equals ()

==est un opérateur et equals()est une méthode .

Les opérateurs sont généralement utilisés pour les comparaisons de type primitif et sont donc ==utilisés pour la comparaison d'adresses mémoire et la equals()méthode est utilisée pour comparer les objets .

 String w1 ="Sarat";
 String w2 ="Sarat";
 String w3 = new String("Sarat");

 System.out.println(w1.hashCode());   //3254818
 System.out.println(w2.hashCode());   //3254818
 System.out.println(w3.hashCode());   //3254818

 System.out.println(System.identityHashCode(w1)); //prints 705927765
 System.out.println(System.identityHashCode(w2)); //prints 705927765
 System.out.println(System.identityHashCode(w3)); //prints 366712642


 if(w1==w2)   //  (705927765==705927765)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

 if(w2==w3)   //  (705927765==366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints false


 if(w2.equals(w3))   //  (Content of 705927765== Content of 366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

N'oubliez pas que cela .equals(...)doit être implémenté par la classe que vous essayez de comparer. Sinon, il n'y a pas grand chose à dire; la version de la méthode pour la classe Object fait la même chose que l'opération de comparaison: Object # est égal .

La seule fois où vous voulez vraiment utiliser l'opérateur de comparaison pour les objets est lorsque vous comparez des énumérations. En effet, il n'y a qu'une seule instance d'une valeur Enum à la fois. Par exemple, étant donné l'énumération

enum FooEnum {A, B, C}

Vous n'aurez jamais plus d'une instance Aà la fois, et la même chose pour BetC . Cela signifie que vous pouvez réellement écrire une méthode comme ceci:

public boolean compareFoos(FooEnum x, FooEnum y)
{
    return (x == y);
}

Et vous n'aurez aucun problème.

Lorsque vous évaluez le code, il est très clair que (==) compare en fonction de l'adresse mémoire, tandis que égal à (Object o) compare hashCode () des instances. C'est pourquoi il est dit de ne pas rompre le contrat entre equals () et hashCode () si vous ne rencontrez pas de surprises plus tard.

    String s1 = new String("Ali");
    String s2 = new String("Veli");
    String s3 = new String("Ali");

    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
    System.out.println(s3.hashCode());


    System.out.println("(s1==s2):" + (s1 == s2));
    System.out.println("(s1==s3):" + (s1 == s3));


    System.out.println("s1.equals(s2):" + (s1.equals(s2)));
    System.out.println("s1.equal(s3):" + (s1.equals(s3)));


    /*Output 
    96670     
    3615852
    96670
    (s1==s2):false
    (s1==s3):false
    s1.equals(s2):false
    s1.equal(s3):true
    */

Voici une règle générale pour la différence entre relational operator ==et the method .equals().

object1 == object2compare si les objets référencés par object1 et object2 se réfèrent au même emplacement mémoire dans Heap .

object1.equals(object2)compare les valeurs de object1 et object2 quel que soit leur emplacement en mémoire .

Cela peut être bien démontré en utilisant String

Scénario 1

 public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = new String("Hello");
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

 }



The result is
      is str1 == str2 ? false
      is str1.equals(str2) ? true 

Scénario 2

public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = "Hello";
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

}

The result is 
  is str1 == str2 ? true
  is str1.equals(str2) ? true

Cette comparaison de chaînes pourrait être utilisée comme base pour comparer d'autres types d'objets.

Par exemple, si j'ai une classe Person , je dois définir la base de critères sur laquelle je comparerai deux personnes . Disons que cette classe de personnes a des variables d'instance de taille et de poids.

Donc, créer des objets personne person1 and person2et comparer ces deux en utilisant la fonction .equals()J'ai besoin de remplacer la méthode égal de la classe personne pour définir en fonction des variables d'instance (hauteur ou poids) de la comparaison.

Cependant, le == operator will still return results based on the memory location of the two objects(person1 and person2).

Pour faciliter la généralisation de cette comparaison d'objet personne, j'ai créé la classe de test suivante. L'expérimentation de ces concepts révélera des tonnes de faits .

package com.tadtab.CS5044;

public class Person {

private double height;
private double weight;

public double getHeight() {
    return height;
}

public void setHeight(double height) {
    this.height = height;
}

public double getWeight() {
    return weight;
}

public void setWeight(double weight) {
    this.weight = weight;
}


@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    long temp;
    temp = Double.doubleToLongBits(height);
    result = prime * result + (int) (temp ^ (temp >>> 32));
    return result;
}

@Override
/**
 * This method uses the height as a means of comparing person objects.
 * NOTE: weight is not part of the comparison criteria
 */
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (Double.doubleToLongBits(height) != Double.doubleToLongBits(other.height))
        return false;
    return true;
}

public static void main(String[] args) {

    Person person1 = new Person();
    person1.setHeight(5.50);
    person1.setWeight(140.00);

    Person person2 = new Person();
    person2.setHeight(5.70);
    person2.setWeight(160.00);

    Person person3 = new Person();
    person3 = person2;

    Person person4 = new Person();
    person4.setHeight(5.70);

    Person person5 = new Person();
    person5.setWeight(160.00);

    System.out.println("is person1 == person2 ? " + (person1 == person2)); // false;
    System.out.println("is person2 == person3 ? " + (person2 == person3)); // true 
    //this is because perosn3 and person to refer to the one person object in memory. They are aliases;
    System.out.println("is person2.equals(person3) ? " + (person2.equals(person3))); // true;

    System.out.println("is person2.equals(person4) ? " + (person2.equals(person4))); // true;

    // even if the person2 and person5 have the same weight, they are not equal.
    // it is because their height is different
    System.out.println("is person2.equals(person4) ? " + (person2.equals(person5))); // false;
}

}

Le résultat de cette exécution de classe est:

is person1 == person2 ? false
is person2 == person3 ? true
is person2.equals(person3) ? true
is person2.equals(person4) ? true
is person2.equals(person4) ? false

Notez également que .equals()contient normalement== pour le test car c'est la première chose que vous souhaitez tester si vous souhaitez tester si deux objets sont égaux.

Et ==regarde les valeurs des types primitifs, pour les objets, il vérifie la référence.

== opérateur toujours référence est comparée. Mais en cas de

méthode equals ()

cela dépend de l'implémentation si nous sommes remplacés par la méthode égale à celle qui compare l'objet sur la base de l'implémentation donnée dans la méthode substituée.

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//fasle
      obj==obj1 // fasle
    }
 }

dans le code ci-dessus, les objets obj et obj1 contiennent les mêmes données mais la référence n'est pas la même, donc égal retourne false et == également. mais si nous avons remplacé la méthode égale à

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }
    public boolean equals(Object obj)
    {
       A a1=(A)obj;
      return this.id==a1.id;
    }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//true
      obj==obj1 // fasle
    }
 }

savoir vérifier, il retournera vrai et faux pour le même cas que nous avons remplacé

est égal à la méthode.

il compare l'objet sur la base du contenu (id) de l'objet

mais ==

toujours comparer les références d'objet.

La principale différence entre == et equals () est

1) == est utilisé pour comparer les primitives.

Par exemple :

        String string1 = "Ravi";
        String string2 = "Ravi";
        String string3 = new String("Ravi");
        String string4 = new String("Prakash");

        System.out.println(string1 == string2); // true because same reference in string pool
        System.out.println(string1 == string3); // false

2) equals () est utilisé pour comparer des objets. Par exemple :

        System.out.println(string1.equals(string2)); // true equals() comparison of values in the objects
        System.out.println(string1.equals(string3)); // true
        System.out.println(string1.equals(string4)); // false

==peut être utilisé dans de nombreux types d'objets, mais vous pouvez l'utiliser Object.equalspour n'importe quel type, en particulier les chaînes et les marqueurs Google Map.

public class StringPool {

public static void main(String[] args) {

    String s1 = "Cat";// will create reference in string pool of heap memory
    String s2 = "Cat";
    String s3 = new String("Cat");//will create a object in heap memory

    // Using == will give us true because same reference in string pool

    if (s1 == s2) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using == with reference and Object will give us False

    if (s1 == s3) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using .equals method which refers to value

    if (s1.equals(s3)) {
        System.out.println("true");
    } else {
        System.out.println("False");
    }

    }
  }

---- Sortie ----- vrai faux vrai

Il peut être utile d'ajouter que pour les objets wrapper pour les types primitifs - c'est-à-dire Int, Long, Double - == retournera vrai si les deux valeurs sont égales.

Long a = 10L;
Long b = 10L;

if (a == b) {
    System.out.println("Wrapped primitives behave like values");
}

En revanche, mettre les deux Longs ci-dessus dans deux ArrayLists séparés, égaux les voit comme les mêmes, mais pas ==.

ArrayList<Long> c = new ArrayList<>();
ArrayList<Long> d = new ArrayList<>();

c.add(a);
d.add(b);
if (c == d) System.out.println("No way!");
if (c.equals(d)) System.out.println("Yes, this is true.");

Le pool de chaînes (alias interning ) et le pool d'entiers estompent davantage la différence et peuvent vous permettre d'utiliser== des objets dans certains cas au lieu de.equals

Cela peut vous donner de meilleures performances (?), Au prix d'une plus grande complexité.

Par exemple:

assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;

Compromis de complexité: les éléments suivants peuvent vous surprendre:

assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;

Je vous conseille de vous tenir à l'écart de cette micro-optimisation, et de toujours l' utiliser .equalspour les objets, et ==pour les primitives:

assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);

Bref, la réponse est "oui".

En Java, l' ==opérateur compare les deux objets pour voir s'ils pointent vers le même emplacement mémoire; tandis que la .equals()méthode compare en fait les deux objets pour voir s'ils ont la même valeur d'objet.

Fondamentalement, == compare si deux objets ont la même référence sur le tas, donc à moins que deux références soient liées au même objet, cette comparaison sera fausse.

equals()est une méthode héritée de la Objectclasse. Cette méthode compare par défaut si deux objets ont la même référence. Ça veut dire:

object1.equals(object2) <=> object1 == object2

Cependant, si vous souhaitez établir l'égalité entre deux objets de la même classe, vous devez remplacer cette méthode. Il est également très important de remplacer la méthode hashCode()si vous avez remplacéequals() .

Implémenter hashCode()lors de l'établissement de l'égalité fait partie du contrat d'objet Java. Si vous travaillez avec des collections et que vous ne les avez pas implémentées hashCode(), Strange Bad Things peut se produire:

HashMap<Cat, String> cats = new HashMap<>();
Cat cat = new Cat("molly");
cats.put(cat, "This is a cool cat");
System.out.println(cats.get(new Cat("molly"));

nullsera imprimé après l'exécution du code précédent si vous ne l'avez pas implémenté hashCode().

Étant donné que Java ne prend pas en charge la surcharge des opérateurs, == se comporte de la même manière pour chaque objet, mais equals () est une méthode qui peut être remplacée en Java et la logique de comparaison des objets peut être modifiée en fonction des règles métier.

La principale différence entre == et equals en Java est que "==" est utilisé pour comparer les primitives tandis que la méthode equals () est recommandée pour vérifier l'égalité des objets.

La comparaison de chaînes est un scénario courant d'utilisation à la fois de la méthode == et de l'égalité. Étant donné que la classe java.lang.String remplace la méthode equals, elle renvoie true si deux objets String contiennent le même contenu, mais == ne renvoie true que si deux références pointent vers le même objet.

Voici un exemple de comparaison de deux chaînes en Java pour l'égalité en utilisant la méthode == et equals (), ce qui effacera certains doutes:

public class TEstT{

    public static void main(String[] args) {

String text1 = new String("apple");
String text2 = new String("apple");

//since two strings are different object result should be false
boolean result = text1 == text2;
System.out.println("Comparing two strings with == operator: " + result);

//since strings contains same content , equals() should return true
result = text1.equals(text2);
System.out.println("Comparing two Strings with same content using equals method: " + result);

text2 = text1;
//since both text2 and text1d reference variable are pointing to same object
//"==" should return true
result = (text1 == text2);
System.out.println("Comparing two reference pointing to same String with == operator: " + result);

}
}