Qual è la differenza tra ".equals" e "=="? [duplicare]

Question

    

Questa domanda ha già una risposta qui:

    

        
•              Qual è la differenza tra == ed equals () in Java?                                      23 risposte                          
    

    

Oggi ho cambiato docente e mi ha dichiarato di usare un codice strano. (Ha detto che è meglio usare .equals e quando ho chiesto perché, ha risposto " perché è! & Quot;)

Quindi ecco un esempio:

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

Invece di quello a cui sono abituato:

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

Qual è la differenza tra i due. E perché la sua strada (usando .equals ) è migliore?

Trovato questo su un ricerca rapida ma non riesco davvero a dare un senso a quella risposta:

Answer 1

In Java, == confronta sempre solo due riferimenti (per i non primitivi, cioè) - ovvero verifica se i due operandi si riferiscono allo stesso oggetto.

Tuttavia, il metodo equals può essere ignorato, quindi due oggetti distinti possono essere uguali.

Ad esempio:

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

Inoltre, vale la pena tenere presente che due uguali costanti di stringa (principalmente valori letterali di stringa, ma anche combinazioni di costanti di stringa tramite concatenazione) finiranno per fare riferimento alla stessa stringa. Ad esempio:

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

Qui x e y sono riferimenti alla stessa stringa, perché y è una costante di tempo di compilazione pari a " ciao ".

Answer 2

L'operatore == confronta se gli oggetti sono la stessa istanza . L'eratore equals () confronta lo stato degli oggetti (ad es. Se tutti gli attributi sono uguali). Puoi anche sostituire il metodo equals () per definirti quando un oggetto è uguale a un altro.

Answer 3

Se tu ed io entriamo tutti in banca, ognuno apre un nuovo account e ogni deposito $ 100, quindi ...

1. myAccount.equals (yourAccount) è true perché hanno lo stesso valore , ma
2. myAccount == yourAccount è false perché non sono lo stesso account .

(Supponendo le definizioni appropriate della classe Account , ovviamente. ;-)

Answer 4

== è un operatore. equals è un metodo definito nella classe Object

== controlla se due oggetti hanno lo stesso indirizzo in memoria e per primitivo controlla se hanno lo stesso metodo value.equals d'altra parte controlla se i due oggetti che vengono confrontati hanno un valore uguale (a seconda di ovviamente il metodo equals è stato implementato per gli oggetti. il metodo equals non può essere applicato alle primitive (il che significa che se a è una primitiva a.equals (someobject) non è consentita, tuttavia someobject.equals (a) è consentita).

Answer 5

L'operatore

== confronta due riferimenti a oggetti per verificare se si riferiscono alla stessa istanza. Anche questo, tornerà vero su match.for esempio riuscito

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

sopra l'esempio == è un confronto di riferimento, ovvero entrambi gli oggetti puntano alla stessa posizione di memoria

String equals () viene valutato per il confronto dei valori negli oggetti.

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

sopra l'esempio Confronta il contenuto delle stringhe. Restituirà vero se la stringa corrisponde, altrimenti restituisce falso.

Answer 6

In Java, quando l'operatore & # 8220; == & # 8221; viene utilizzato per confrontare 2 oggetti, verifica se gli oggetti si riferiscono allo stesso posto in memoria. 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");

Anche se le stringhe hanno gli stessi caratteri esatti (& # 8220; xyz & # 8221;), il codice sopra mostrerà effettivamente:  obj1 == obj2 è FALSE

La classe String Java sovrascrive effettivamente l'implementazione predefinita equals () nella classe Object & # 8211; e sovrascrive il metodo in modo che controlli solo i valori delle stringhe, non le loro posizioni in memoria. Ciò significa che se si chiama il metodo equals () per confrontare 2 oggetti String, quindi finché la sequenza effettiva di caratteri è uguale, entrambi gli oggetti vengono considerati uguali.

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");

Questo codice genererà quanto segue:

obj1 == obj2 è TRUE

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

Qui in questo codice puoi campare sia '==' che '.equals'

qui .equals viene utilizzato per confrontare gli oggetti di riferimento e '==' per confrontare lo stato degli oggetti ..

Answer 8

(1) == può essere applicato sia per i primitivi che per i tipi di oggetto, ma il metodo equals () può essere applicato solo per i tipi di oggetto.

(2) == non può essere sovrascritto per il confronto dei contenuti, ma il metodo uguale può essere ignorato per il confronto dei contenuti (ad es. classe String, classi wrapper, classi di raccolta).

(3) == restituisce un errore di tipo incomparabile quando si tenta di applicare tipi eterogenei, dove il metodo equals restituisce false.

Answer 9

Il metodo equals () e l'operatore == eseguono due diverse operazioni. Il metodo equals () confronta i caratteri all'interno di un oggetto String . L'operatore == confronta due riferimenti a oggetti per vedere se si riferiscono alla stessa istanza. Il seguente programma mostra come due diversi oggetti String possono contenere gli stessi caratteri, ma i riferimenti a questi oggetti non verranno confrontati come uguali:

// 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 variabile s1 si riferisce all'istanza String creata da & # 8220; Hello & # 8221; . L'oggetto a cui fa riferimento s2 viene creato con s1 come inizializzatore. Pertanto, il contenuto dei due oggetti String è identico, ma sono oggetti distinti. Ciò significa che s1 e s2 non si riferiscono agli stessi oggetti e non sono pertanto == , come mostrato qui dall'output dell'esempio precedente:

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

Answer 10

Supponiamo che " == " l'operatore restituisce true se entrambi gli operandi appartengono allo stesso oggetto ma quando restituirà true in quanto non è possibile assegnare a un singolo oggetto più valori

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

Ora, quando ciò accade praticamente, se non accade, allora perché questo è == confronta la funzionalità ....

Answer 11

Ecco una semplice interpretazione del tuo problema:

  

== (uguale a) utilizzato per valutare l'espressione aritmetica

dove come

  

metodo equals () utilizzato per confrontare la stringa

Pertanto, è meglio usare == per operazioni numeriche & amp; Metodo equals () per le operazioni relative alle stringhe. Quindi, per il confronto di oggetti il ??metodo equals () sarebbe la scelta giusta.