Utilizzo del metodo equals() con String e Object in Java

Question

Object o1 = new Object(); 
Object o2 = new Object(); 
//o1=o2; 
System.out.println(o1.equals(o2)); 

Restituisce false. Può restituire true, se il commento viene rimosso.

---

Perché non è la stessa cosa applicabile alla classe String?

String s1=new String(); 
String s2=new String(); 
System.out.println(s1.equals(s2)); 

Restituisce true. Perché? (Perché String utilizza stagisti o qualcos'altro coinvolto?)

Answer 1

Perché equals() for String confronta il contenuto, non l'oggetto stesso.

public boolean equals (Object anObject)

confronto tra questa stringa per l'oggetto specificato. Il risultato è true se e solo se l'argomento non è null ed è un oggetto String che rappresenta la stessa sequenza di caratteri di questo oggetto.

/* String.equals() */ 
public boolean equals(Object anObject) { 
    if (this == anObject) { 
     return true; 
    } 
    if (anObject instanceof String) { 
     String anotherString = (String)anObject; 
     int n = count; 
     if (n == anotherString.count) { 
      char v1[] = value; 
      char v2[] = anotherString.value; 
      int i = offset; 
      int j = anotherString.offset; 
      while (n-- != 0) { 
       if (v1[i++] != v2[j++]) 
        return false; 
      } 
      return true; 
     } 
    } 
    return false; 
} 

(Link alla fonte della String.equals())

Versus the equals for Object:

Il uguale metodo per la classe Object implementa la più esigente relazione di equivalenza possibile in oggetti; ovvero, per qualsiasi valore di riferimento non null x e , questo metodo restituisce true se e solo se x e si riferiscono allo stesso oggetto (x == y ha il valore true).

/* Object.equals() */ 
public boolean equals(Object obj) { 
    return (this == obj); 
} 

(Link alla fonte della Object.equals())

Inoltre, non dimenticare il contratto della funzione equals():

il metodo equals implementa una relazione di equivalenza sulla non riferimenti a oggetti null:

• È riflessa: per qualsiasi valore di riferimento non nullo x, x.equals(x) deve restituire true.
• È simmetrica: per tutti i valori di riferimento non nulli x e y, x.equals(y) dovrebbe restituire vero se e solo se y.equals(x) restituisce true.
• È transitivo: per tutti i valori di riferimento non nulli x, y e z, se x.equals(y) rendimenti true e y.equals(z) ritorni true, quindi x.equals(z) dovrebbero restituire true.
• È coerente: per tutti i valori di riferimento non nulli x e y, molteplici invocazioni di x.equals(y) costantemente tornare true o costantemente tornare false, fornito alcuna informazione utilizzata in uguale confronti sugli oggetti vengono modificati.
• Per qualsiasi valore di riferimento non nullo x, x.equals(null) deve restituire false.

letture consigliate anche:

• Object.hashCode()
• Effective Java (Bloch)

Answer 2

equals per Object confronta i riferimenti di memoria.
Ecco perché è falso poiché sono diversi Object s
equals per String viene sovrascritto in base ai caratteri.
Hai 2 oggetti vuoti String, ecco perché equals restituisce true.

Answer 3

Il equals implementato nella classe Object confronta solo i riferimenti. Ecco il codice sorgente:

public boolean equals(Object obj) { 
return (this == obj); 
} 

Answer 4

uguale metodo deve essere sovrascritto all'interno della classe, se si desidera rendere comportarsi in qualche altro modo. Per impostazione predefinita, controlla se due riferimenti si riferiscono allo stesso oggetto.

Answer 5

== confronta gli indirizzi degli oggetti/corde/qualsiasi cosa

.equals() progettato per utilizzare stato interno degli oggetti per il confronto.

Quindi:

new Object() == new Object() => false - due oggetti separati in zone diverse di memoria.

new String("a") == new String("a") => false - la stessa situazione: due indirizzi separati per gli oggetti stringa.

new String("a").equals(new String("a")) => true - gli indirizzi sono diversi, ma Java prenderà uno stato oggetto ('a') e confrontato con altri stati oggetto ('a') li troverà uguali e segnaleranno true.

Utilizzando il metodo equals() è possibile codificare il confronto in qualsiasi modo sia corretto per il proprio programma.

intern() è una storia un po 'diversa. È inteso per restituire lo stesso oggetto (indirizzo) per la stessa sequenza di caratteri. È utile ridurre la quantità di memoria richiesta quando si costruiscono le stesse stringhe più volte.

new String("aaa").intern() cercherà nella memoria della macchina se mai qualcuno ha creato una stringa "aaa" prima e restituirà la prima istanza della stringa ... Se non è stata trovata la stringa, quella corrente verrà inserita come prima e tutta "aaa" .intern() e new String("aaa").intern() e ("a"+"aa").intern() restituiranno tale "prima" istanza.

Attenzione: "aaa".intern() non è un'operazione molto veloce e se si internerà tutte le stringhe - si risparmia un po 'di memoria, ma si perderanno un bel po' di lavoro della CPU.

Answer 6

Il metodo equals() della classe Object non sa come confrontare le stringhe, sa solo come confrontare gli oggetti. Per confrontare le stringhe, una classe stringa sostituirà il metodo equals() e confronterà le stringhe in essa contenute.

Object.equals() confronta solo i riferimenti, dove String.equals() confronterà i valori.