Quelle est la différence entre & # 8220; .equals & # 8221; et & # 8220; == & # 8221 ;? [dupliquer]

Question

    

Cette question a déjà une réponse ici:

    

        
•              Quelle est la différence entre == et equals () en Java?                                      23 réponses                          
    

    

J'ai changé de conférencier aujourd'hui et il a déclaré utiliser un code étrange pour moi. (Il a dit qu'il était préférable d'utiliser .equals et quand j'ai demandé pourquoi, il a répondu "parce que c'est le cas!")

Alors, voici un exemple:

if (o1.equals(o2))
{
 System.out.println("Both integer objects are the same");
}

Au lieu de ce à quoi je suis habitué:

if (o1 == o2)
{
  System.out.println("Both integer objects are the same");
}

Quelle est la différence entre les deux. Et pourquoi sa manière (en utilisant .equals ) est-elle meilleure?

trouvé ceci sur un recherche rapide mais je ne peux pas vraiment comprendre cette réponse:

Answer 1

En Java, == ne fait que comparer deux références (c'est-à-dire pour les non-primitives), c'est-à-dire qu'il vérifie si les deux opérandes font référence au même objet.

Cependant, la méthode equals peut être remplacée - deux objets distincts peuvent donc être égaux.

Par exemple:

String x = "hello";
String y = new String(new char[] { 'h', 'e', 'l', 'l', 'o' });

System.out.println(x == y); // false
System.out.println(x.equals(y)); // true

De plus, sachez que deux constantes de chaîne égales (principalement des chaînes littérales, mais également des combinaisons de constantes de chaîne via une concaténation) finiront par faire référence à la même chaîne. Par exemple:

String x = "hello";
String y = "he" + "llo";
System.out.println(x == y); // true!

Ici, x et y sont des références à la même chaîne, car y est une constante de compilation égale à " bonjour " .

Answer 2

L'opérateur == compare si les objets sont la même instance . L'agent equals () compare l'état des objets (par exemple, si tous les attributs sont égaux). Vous pouvez même remplacer la méthode equals () pour vous définir quand un objet est égal à un autre.

Answer 3

Si vous et moi nous trouvons chacun à la banque, vous ouvrez chacun un nouveau compte et déposez chacun 100 $, puis ...

1. myAccount.equals (votre compte) est true car ils ont la même valeur , mais
2. monCompte == votreCompte est faux car il ne s'agit pas du même compte .

(En supposant que les définitions appropriées de la classe Account , bien sûr.; -)

Answer 4

== est un opérateur. equals est une méthode définie dans la classe Object

== vérifie si deux objets ont la même adresse dans la mémoire et, pour les primitives, vérifie s'ils ont la même valeur. equals vérifie si les deux objets comparés ont une valeur égale comment bien sûr la méthode equals a été implémentée pour les objets. La méthode equals ne peut pas être appliquée aux primitives (ce qui signifie que si a est une primitive, a.equals (someobject) n’est pas autorisé, mais someobject.equals (a) est autorisé).

Answer 5

== l'opérateur compare deux références d'objet pour vérifier si elles se réfèrent à la même instance. Ceci aussi retournera true en cas de match réussi. Par exemple,

public class Example{
public static void main(String[] args){
String s1 = "Java";
String s2 = "Java";
String s3 = new string ("Java");
test(Sl == s2)     //true
test(s1 == s3)      //false
}}

ci-dessus, exemple == est une comparaison de référence, c'est-à-dire que les deux objets pointent vers le même emplacement de mémoire

String equals () est évalué à la comparaison des valeurs des objets.

   public class EqualsExample1{
   public static void main(String args[]){
   String s = "Hell";
   String s1 =new string( "Hello");
   String s2 =new string( "Hello");
   s1.equals(s2);    //true
    s.equals(s1) ;   //false
    }}

ci-dessus exemple Il compare le contenu des chaînes. Il retournera la valeur true si la chaîne correspond, sinon la valeur false.

Answer 6

En Java, lorsque l'opérateur & # 8220; == & # 8221; est utilisé pour comparer 2 objets, il vérifie si les objets font référence au même emplacement en mémoire. EX:

String obj1 = new String("xyz");
String obj2 = new String("xyz");
if(obj1 == obj2)
   System.out.println("obj1==obj2 is TRUE");
else
  System.out.println("obj1==obj2 is FALSE");

Même si les chaînes ont exactement les mêmes caractères (& # 8220; xyz & # 8221;), le code ci-dessus sera en réalité généré:  obj1 == obj2 est FALSE

La classe

Java String remplace en réalité l’implémentation par défaut equals () dans la classe Object & # 8211; et il remplace la méthode pour ne vérifier que les valeurs des chaînes, et non leurs emplacements en mémoire. Cela signifie que si vous appelez la méthode equals () pour comparer 2 objets String, tant que la séquence de caractères est identique, les deux objets sont considérés comme égaux.

String obj1 = new String("xyz");
String obj2 = new String("xyz");
if(obj1.equals(obj2))
   System.out.printlln("obj1==obj2 is TRUE");
else
  System.out.println("obj1==obj2 is FALSE");

Ce code produira les informations suivantes:

obj1 == obj2 est VRAI

Answer 7

public static void main(String[] args){
        String s1 = new String("hello");
        String s2 = new String("hello");

        System.out.println(s1.equals(s2));
        ////
        System.out.println(s1 == s2);

    System.out.println("-----------------------------");

        String s3 = "hello";
        String s4 = "hello";

        System.out.println(s3.equals(s4));
        ////
        System.out.println(s3 == s4);
    }

Ici, dans ce code, vous pouvez comparer le '==' et le '.equals'

ici .equals est utilisé pour comparer les objets de référence et '==' pour comparer l’état des objets.

Answer 8

(1) == peut être appliqué à la fois aux primitives et aux types d'objet, mais la méthode equals () ne peut être appliquée qu'à des types d'objet.

(2) == ne peut pas être remplacé pour la comparaison de contenu, mais la méthode equals peut être remplacé pour la comparaison de contenu (ex: classe String, classes wrapper, classes de collection).

(3) == donne une erreur de types incomparable lorsque vous essayez d'appliquer des types hétérogènes, où la méthode égal à égal renvoie false.

Answer 9

La méthode equals () et l'opérateur == effectuent deux opérations différentes. La méthode equals () compare les caractères d'un objet String . L'opérateur == compare deux références d'objet pour voir si elles font référence à la même instance. Le programme suivant montre comment deux objets String différents peuvent contenir les mêmes caractères, mais les références à ces objets ne seront pas équivalentes:

// equals() vs ==
class EqualsNotEqualTo {
     public static void main(String args[]) {
          String s1 = "Hello";
          String s2 = new String(s1);
          System.out.println(s1 + " equals " + s2 + " -> " +
          s1.equals(s2));
          System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2));
     }
}

La variable s1 fait référence à l'instance String créée par & # 8220; Hello & # 8221; . L'objet mentionné par s2 est créé avec s1 comme initialiseur. Ainsi, le contenu des deux objets String est identique, mais ce sont des objets distincts. Cela signifie que s1 et s2 ne font pas référence aux mêmes objets et ne sont donc pas == , comme le montre le résultat de l'exemple précédent:

Hello equals Hello -> true
Hello == Hello -> false

Answer 10

Disons que " == " L'opérateur retourne la valeur true si les deux opérandes appartiennent au même objet, mais la valeur renvoyée est true car nous ne pouvons pas affecter plusieurs valeurs à un seul objet

public static void main(String [] args){
    String s1 = "Hello";
    String s1 = "Hello";  // This is not possible to assign multiple values to single object
    if(s1 == s1){
      // Now this retruns true
   }
}

Maintenant, lorsque cela se produit pratiquement, si cela ne se produit pas, pourquoi == compare les fonctionnalités ....

Answer 11

Voici une interprétation simple de votre problème:

  

== (égal à) utilisé pour évaluer l'expression arithmétique

où comme

  

Méthode equals () utilisée pour comparer une chaîne

Par conséquent, il est préférable d’utiliser == pour les opérations numériques & amp; Méthode equals () pour les opérations liées à String. Ainsi, pour la comparaison d’objets, la méthode equals () serait un bon choix.