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

en ce qui concerne la classe de chaîne:

the equals () method compare la" valeur " dans les instances de chaîne (sur le tas) indépendamment si les deux références d'objet se réfèrent à la même instance de chaîne ou non. Si deux références d'objet de type String se réfèrent à la même instance de String alors Grande! Si les deux références d'objet se réfèrent à deux instances de chaîne différentes .. il ne fait pas de différence. Sa "valeur" (ce qui est: le contenu de le tableau de caractères) à l'intérieur de chaque instance de Chaîne qui est comparé.

, d'autre part, le "==" opérateur compare la valeur de deux références de l'objet pour voir si elles se réfèrent à la même instance de Chaîne . Si la valeur des deux références de l'objet "voir" 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 les références d'objet "font référence à" différentes instances de chaîne (même si les deux instances de chaîne ont des "valeurs"identiques, c'est-à-dire que le contenu des tableaux de caractères de chaque instance de chaîne sont les mêmes) le résultat de l'expression booléenne serait "false".

comme pour toute explication, laissez-la s'enfoncer.

j'espère que ça éclaircira 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 tous les ci-dessus...

, 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 ".égal.(..)" (méthode en java.lang.Classe objet) à travers ces liens:

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

la différence entre = = et les égaux m'a embrouillé 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 la chaîne de caractères, vous devez utiliser equals et non == . J'espère que dans cette réponse je pourrai dire la différence.

la meilleure façon de répondre à cette question sera de vous poser quelques questions. alors commençons:

Quel est le résultat pour le programme ci-dessous:

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

si vous dites,

false
true

je dirai que vous êtes droit mais pourquoi avez-vous dit que ? et si vous dites que la sortie est,

true
false

je vais dire que vous êtes mauvais mais je vais quand même vous demander pourquoi vous pensez que c'est vrai?

OK, essayons de répondre à celle-ci:

Quel est le résultat 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 vous êtes erroné 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 réfléchir.

Ok. Maintenant, ceci pourrait aider (s'il vous plaît lire ceci : imprimer l'adresse de l'objet - pas possible, mais encore nous pouvons 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 imprimé ( vous pouvez vérifier le code ici ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

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

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

Maintenant, essayez de décommenter cette ligne // mango2 = "mang"; et l'exécuter à nouveau cette fois vous voir 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 suis pas sûr du fonctionnement interne de java mais je suppose que c'est ce qui s'est passé quand j'ai dit:

mango = "mango";

java a créé une chaîne de caractères "mango" qui a été pointée(référencée) par la variable mango quelque chose comme ceci

mango ----> "mango"

maintenant à la ligne suivante quand j'ai dit:

mango2 = "mango";

il a en fait réutilisé la même chaîne "mango" qui semble quelque chose comme ça

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

mango et mango2 pointant 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"mango". ce qui ressemble à ça,

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

mango3 ------> "mango"

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

et quand vous avez décommenté la ligne // mango2 = "mang"; Il a en fait créé une chaîne "mang" qui a tourné notre graphe 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 ça vous aidera. En fait, je voulais générer un cas de test où == échoue et égale() réussit. N'hésitez pas à commenter et laissez-moi savoir Si je me trompe.

le = = l'opérateur teste si deux variables ont les mêmes références (alias pointer 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 égale () 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)

santé :-)

vous devrez outrepasser la fonction equals (avec d'autres) pour l'utiliser avec des classes personnalisées.

la méthode equal compare les objets.

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

les Deux == et .equals () fait référence au même objet si vous ne l'annulez pas .égal.)(

C'est votre souhait ce que vous voulez faire une fois que vous annulez .égal.)( Vous pouvez comparer l'invocation de l'objet d'état avec le passé dans l'objet de l'état ou vous pouvez les appeler super.égal ()

n'oubliez pas que .equals(...) doit être implémenté par la classe que vous essayez de comparer. Sinon, il n'y a pas beaucoup de point; la version de la méthode pour la classe objet fait la même chose que l'opération de comparaison: objet#égale .

la seule fois où vous voulez vraiment utiliser l'opérateur de comparaison pour les objets est Wen vous comparez des Énums. C'est parce qu'il n'existe qu'une seule instance d'une valeur d'énumération à la fois. Pour exemple, étant donné l'enum

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 suit:

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

et vous n'aurez aucun problème.

 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

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

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

the == opérateur:

L' == 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 égales, l'opérateur == renvoie une valeur vraie. Cependant, si les deux opérandes ne sont pas égales, il renvoie un faux valeur. Lorsqu'il est utilisé avec des objets, l'opérateur == compare les deux références d'objet et détermine si elles se réfèrent à la même instance.

The .= () méthode 151910920"

equals() est une méthode disponible dans la classe String qui est utilisée pour comparer deux chaînes et déterminer si elles sont égales. Cette méthode renvoie une valeur booléenne comme un résultat de la comparaison. Si les deux chaînes contiennent les mêmes caractères dans le même ordre, la méthode equals() renvoie vrai. Sinon, elle renvoie la valeur false.

Pour Exemples:

http://goo.gl/Sa3q5Y

"==" comparons en fait les deux références d'objet pour voir si elles pointent vers le même objet.

"equals" qui est une "comparaison profonde" qui compare les valeurs réelles des chaînes.

notez Également que .equals() contient normalement == pour les essais, comme c'est la première chose que vous souhaitez tester si vous voulais tester si deux objets sont égaux.

et == regarde en fait les valeurs pour les types primitifs, pour les objets il vérifie la référence.

lorsque vous évaluez le code, il est très clair que (==) compare selon l'adresse mémoire, tandis que equals(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 faites pas face à des 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
    */

la différence majeure 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 utiliser Object.equals pour tout type, en particulier les chaînes de caractères et les marqueurs Google Map.

= = référence de l'opérateur est toujours comparée. Mais dans le cas de

égale() méthode

cela dépend de l'implémentation si nous sommes la méthode overridden equals qu'elle compare l'objet sur la base de l'implémentation donné dans la méthode overridden.

 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, l'objet obj et obj1 contient les mêmes données, mais la référence n'est pas la même donc égale à return false et == aussi. mais si nous remplacé méthode equals que

 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 consulter il sera de retour le vrai et le faux pour le même cas seulement nous avons remplacé

égale méthode .

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

mais " = =

encore comparer les références de l'objet.

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 intéressant d'ajouter que pour les objets wrapper pour les types primitifs - i.e. Int, Long, Double - == retournera true si les deux valeurs sont égales.

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

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

pour Contraste, mettant les deux Longs ci-dessus dans deux ArrayLists séparés, égale les voit comme les mêmes, mais == ne le fait 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.");

the String pool (alias interning ) and Integer pool flou la différence plus loin, et peut vous permettre d'utiliser == pour les objets dans certains cas au lieu de .equals

cela peut vous donner une plus grande performance (?), au prix d'une plus grande complexité.

par exemple:

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

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

Echange de complexité: ce qui suit peut vous surprendre:

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

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

je vous conseille de rester à l'écart d'une telle micro-optimisation, et toujours utiliser .equals pour les objets, et == pour les primitives:

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

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

essentiellement, == 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 Object classe. Cette méthode par défaut compare si deux objets ont la même référence. Cela signifie:

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

cependant, si vous voulez établir l'égalité entre deux objets de la même classe, vous devez outrepasser cette méthode. Il est également très important de modifier la méthode hashCode() si vous avez modifié equals() .

mettre en Œuvre hashCode() lors de l'établissement de l'égalité est une partie de l'Objet Java Contrat. Si vous travaillez avec des collections, et que vous n'avez pas mis en œuvre hashCode() , des mauvaises choses étranges pourraient 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"));

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

En général, les deux equals() et "==" opérateur en Java sont utilisés pour comparer des objets pour vérifier l'égalité, mais voici quelques-unes des différences entre les deux:

principale différence entre .méthode equals() et l'opérateur == est que l'on est une méthode et d'autres en est l'exploitant.

nous pouvons utiliser == les opérateurs pour la comparaison de référence (comparaison d'adresse) et .méthode equals() pour le contenu de la comparaison. En termes simples, == vérifie si les deux objets à la même emplacement de mémoire alors que .equals() correspond à la comparaison des valeurs dans les objets. Si une classe ne supplante pas la méthode equal, alors par défaut elle utilise la méthode equal(Object o) de la classe mère la plus proche qui a supplanté cette méthode. Voir pour plus de détails

puisque Java ne supporte pas la surcharge de l'opérateur, = = se comporte de manière identique pour chaque objet, mais égale () est la méthode, qui peut être dépassée dans Java et la logique pour comparer des objets peuvent être changés en fonction des affaires règle.

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

la comparaison des chaînes de caractères est un scénario courant d'utilisation à la fois = = et égale la méthode. depuis java.lang.Classe de chaîne de caractères override égale méthode, It retourner true si deux objets String contiennent le même contenu mais = = will 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 () qui dissipera quelques 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);

}
}