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


Je voulais clarifier si je comprends bien:

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

Ai-je raison de comprendre?


470
2017-09-22 19:36


origine


Réponses:


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

  • .equals(...) ne comparera que ce qu'il est écrit pour comparer, pas plus, pas moins.
  • Si une classe ne remplace pas la méthode equals, la valeur par défaut est equals(Object o) méthode de la classe parent la plus proche qui a surchargé cette méthode.
  • Si aucune classe parente n'a fourni un remplacement, elle utilise par défaut la méthode issue de la classe parente ultime, Object, et vous êtes donc Object#equals(Object o) méthode. Par l'API Object, c'est la même chose que ==; c'est-à-dire qu'il retourne vrai si et seulement si les deux variables se réfèrent au même objet, si leurs références sont identiques. Ainsi, vous allez tester pour égalité d'objet et pas égalité fonctionnelle.
  • Rappelez-vous toujours de remplacer hashCode si vous remplacez equals afin de ne pas "casser le contrat". Selon l’API, le résultat renvoyé par le hashCode() méthode pour deux objets doit être le même si leur equals les méthodes montrent qu'elles sont équivalentes. L'inverse est ne pas nécessairement vrai.

487
2017-09-22 19:39



En ce qui concerne la classe String:

Les égaux () méthode compare la "valeur" à l'intérieur des instances de String (sur le tas) indépendamment du fait 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 String, alors c'est génial! Si les deux références d'objet se réfèrent à deux instances String différentes, cela ne fait pas de 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 à comparer.

Par contre, le "==" 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 "se réfère" à la même instance String alors le résultat de l'expression booléenne serait "true" .. duh. Si, par contre, la valeur des deux références d'objet "se réfère à" différentes instances de chaîne (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 identique), le résultat de l'expression booléenne serait "false".

Comme pour toute explication, laissez-la couler.

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


88
2018-05-29 20:24



Il y a quelques petites différences selon que vous parlez de "primitives" ou de "types d'objet"; on peut dire la même chose si vous parlez de membres «statiques» ou «non statiques»; vous pouvez aussi 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 pour "==" (opérateur d'égalité) et ".equals (...)" (méthode dans la classe java.lang.Object) via ces liens:


47
2018-03-06 01:56



La différence entre == et égaux m'a troublé 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 des chaînes, vous devez utiliser equals et pas ==. 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 vais te dire que tu es droite mais pourquoi as-tu dis cela? et si vous dites que la sortie est,

true
false

Je vais te dire que tu es faux mais je vais quand même vous demander 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 vais te dire que tu es faux mais pourquoi est-ce faux maintenant? la sortie correcte pour ce programme est

true
false

Veuillez comparer le programme ci-dessus et essayez d'y réfléchir.

D'accord. Maintenant, cela pourrait aider (s'il vous plaît lire ceci: imprimer l'adresse de l'objet - pas possible mais on peut quand même 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 a imprimé ceci (vous pouvez vérifier le code ici):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Oh! Maintenant vous voyez la identityHashCode (mango) est égal à identityHashCode (mango2) Mais il n'est pas égal à identityHashCode (mango3)

Même si toutes les variables de chaîne - mangue, mangue2 et mangue3 - ont le même valeur, qui est "mangue", identityHashCode() n'est toujours pas la même chose pour tous.

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

nous savons que si hashcode(x)=N et 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 est arrivé quand j'ai dit:

mango = "mango";

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

mango ----> "mango"

Maintenant dans la ligne suivante quand j'ai dit:

mango2 = "mango";

Il a effectivement réutilisé la même chaîne "mango" qui ressemble à quelque chose comme ça

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

La mangue et le mango2 indiquent tous deux la même référence Maintenant quand j'ai dit

mango3 = new String("mango")

En fait, il a créé une référence complètement nouvelle (chaîne) pour "mangue". qui ressemble à ceci,

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

mango3 ------> "mango"

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

et quand vous avez décommenté la ligne // mango2 = "mang"; Il a effectivement créé une chaîne "mang" qui a tourné 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 () passe. S'il vous plaît n'hésitez pas à commenter et laissez-moi savoir si je me trompe.


32
2018-04-05 10:55



le == l'opérateur teste si deux variables ont le 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)

Tandis que le équivaut à() méthode teste si deux variables font référence à 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é :-)


25
2017-08-09 14:43



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

La méthode equals compare les objets.

le == l'opérateur binaire compare les adresses de mémoire.


11
2017-09-22 19:39



Les deux == et .equals () fait référence au même objet si vous ne surchargez 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 invoquant avec l'état de l'objet passé ou vous pouvez simplement appeler super.equals ()


5
2017-09-22 19:54



Rappelez-vous juste que .equals(...) doit être mis en œuvre par la classe que vous essayez de comparer. Sinon, il n'y a pas grand-chose. la version de la méthode pour la classe Object fait la même chose que l'opération de comparaison: L'objet # est égal à.

La seule fois où vous voulez vraiment utiliser l'opérateur de comparaison pour les objets, c'est que vous comparez Enums. C'est parce qu'il n'y a qu'une seule instance d'une valeur Enum à la fois. Par exemple, compte tenu de la énumération

enum FooEnum {A, B, C}

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

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

Et vous n'aurez aucun problème.


5
2017-09-22 21:22



 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

5
2018-01-09 18:06



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

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


5
2018-01-15 03:23



L'opérateur ==:

Le == est un opérateur relationnel en Java qui est utilisé pour comparer deux opérandes. Il est utilisé pour déterminer si les deux opérandes sont égaux ou non. En utilisant l'opérateur ==, vous pouvez comparer n'importe quel type primitif tel que int, char, float et Booleans. Après comparaison, l'opérateur == renvoie une valeur booléenne. Si les deux opérandes sont égaux, l'opérateur == renvoie une valeur vraie. Cependant, si les deux opérandes ne sont pas égaux, cela renvoie une valeur fausse. Lorsqu'il est utilisé avec des objets, l'opérateur == compare les deux références d'objet et détermine s'il fait référence à la même instance.

La méthode .equals ()

equals () est une méthode disponible dans la classe String utilisée pour comparer deux chaînes et déterminer si elles sont égales. Cette méthode renvoie une valeur booléenne à la suite de la comparaison. Si les deux chaînes contiennent les mêmes caractères dans le même ordre, la méthode equals () renvoie true. Sinon, il renvoie une valeur fausse.

Pour des exemples:

http://goo.gl/sa3q5y


4
2017-09-29 03:54