perché equals () metodo quando abbiamo == operatore?

Quando vedo l’implementazione del metodo equals() non fa altro che lo stesso di == . Quindi la mia domanda è: qual è stata la necessità di avere questo come metodo separato quando abbiamo un operatore == che fa lo stesso lavoro?

Non puoi sovraccaricare l’operatore == , ma puoi sovrascrivere equals(Object) se vuoi che si comporti diversamente dall’operatore == , cioè non confrontare i riferimenti ma effettivamente confrontare gli oggetti (ad esempio usando tutti o alcuni dei loro campi).

Inoltre, se si esegue l’override di equals(Object) , dare un’occhiata anche a hashCode() . Questi due metodi devono essere compatibili (ad esempio, due oggetti uguali secondo equals(Object) devono avere lo stesso hashCode() ), altrimenti si verificano tutti gli errori strani (ad esempio quando si aggiungono oggetti a un set o mappa) .

== confronta i riferimenti agli oggetti e chiede se i due riferimenti sono uguali.

equals() confronta il contenuto dell’object e chiede se gli oggetti rappresentano lo stesso concetto.

In caso di primitive , l’operatore == controlla se due valori sono uguali.
Se non sono primitive, controlla se sono due puntatori (o riferimenti ) che puntano alla stessa istanza di un object.

Il metodo equals() esegue un controllo personalizzato, che si trova in Object controllando il riferimento, usando == . Ma in altre classi, a volte equals() è sovrascritto (non so se questo è un participio passato corretto) . equals() deve controllare il contenuto .

Quindi, ad esempio:

 int i0 = 34; int i1 = 34; int i2 = 35; // results i0 == i1: true i1 == i0: true i2 == i0: false 

Ma se abbiamo non primitivi

 String str0 = new String("Hello man!"); String str1 = new String("Hello man!"); String str2 = new String("!nam olleH"); String str2copy = str2; // Results str0 == str1: false // Pointer to two different object, so == will give false str1 == str2: false // Idem str2 == str2copy: true // So this are two pointers to the same object str0.equals(str1): true // This are not the same objects, but they are equal str1 == str1: true // Again: two times a pointer to the same object 

Quindi, perché str0.equals(str1) restituisce true ? Perché la class String ha un override di equals() . E in quel metodo non controlla se sono uguali facendo return this == obj; Ma in quel metodo, c’è un controllo completo. Non so quale metodo usano per confrontare le due stringhe, ma qui ci sono due modi possibili:

  • Generare dalla stringa due un codice hash e verificare se sono uguali ( int == int )
  • Verifica carattere per carattere se sono uguali.

Quindi spero che questo sia chiaro ora.

C’è una differenza molto importante tra i due.

“==” confronta le istanze dell’object. L’implementazione di default equals () fa anche questo. Esegui e analizza il seguente esempio di codice:

 public class Person{ String name; public Person(String name){ this.name = name; } //overriding equals public boolean equals( Object obj ) { if( this == obj ) return true; if( obj == null ) return false; if( getClass() != obj.getClass() ) return false; Person other = (Person) obj; if( name == null ) { if( other.name != null ) return false; } else if( !name.equals( other.name ) ) return false; return true; } } ... ... Person john1 = new Person("John"); Person john2 = new Person("John"); System.out.println("john1 == john2:" + (john1 == john2)); System.out.println("john1.equals(john2):" + john1.equals(john2)); 

Come puoi vedere, “==” restituirà false (gli oggetti sono due diverse istanze di Person), mentre equals restituirà true (perché abbiamo definito che 2 Persons sono uguali quando hanno lo stesso nome)

== operatore è usato per confrontare i riferimenti.
Il metodo equals () è definito sulla definizione dell’object.

 Dog d =new Dog(); Collar c =new Collar("Red"); d.setCollar(c); Dog d2=new Dog(); Collar c2=new Collar("Red"); d2.setCollar(c2); d2.getCollar() ==d.getCollar() 

restituirebbe falso indicando che i due cani hanno due diversi oggetti collare (articoli). non condividono lo stesso colletto .

 d2.getCollar().equals(d.getCollar()) 

restituisce true se il Collare è definito come [il Collare è lo stesso se il colore del Collare è lo stesso] i due cani hanno lo stesso colletto colorato.

  class Collar{ String color=""; public Collar(String p0){ this.color=p0; } boolean equals(Object c){ Collar other=(Collar)c; return this.color.equals(other.getColor()); } public String getColor(){ return this.color; } } 

Ciò è fatto in modo da rendere ansible ciò:

 String s1 = new String("foo"); String s2 = new String("foo"); System.out.println(s1 == s2); // false?! Different references! System.out.println(s1.equals(s2)); // true 

Se si controlla l’origine di String#equals() , si vedrà che ha sovrascritto Object#equals() appropriato per confrontare l’array di caratteri interno dell’altro (il valore effettivo ). Anche molte altre classi hanno questo metodo sovrascritto.

“string” == “string” restituirà false “string” .equals (“string”) restituirà true

Con o1 == o2 confronti che l’object 1 è lo stesso object di o2 (per riferimento)

Con o1.equals (o2), a seconda dell’object il metodo equals è sovrascritto e non implementato con qualcosa come “return o1 == o2”

Ad esempio, crea 2 istanze Set Questi 2 oggetti set sono 2 oggetti diversi, puoi aggiungere elementi diversi in uno di questi. set1 == set2 restituirà sempre false ma set1.equals (set2) alla fine restituirà true se il set2 contiene esattamente gli stessi elementi che set1 … e perché il metodo equals è sovrascritto nella class Set …

Uguale implementazione per Set è:

  public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Set s = (Set) o; if (s.size() != c.size()) return false; return containsAll(s); // Invokes safe containsAll() above } 

Nell’operatore java equals (==) opera su dati di due variabili se gli operandi sono di tipi di dati primitivi. Ma se gli operandi sono oggetti, java li confronta usando riferimenti perché non ha modo di capire per confrontare su quale campo o campi dell’object.

Quindi esiste un solo modo di confrontare basato sui campi definiti dall’utente e definito nell’object sovrascrivendo i metodi equals (), poiché l’operatore uguale (==) non può essere sovrascritto in java poiché java non supporta l’override dell’operatore.

Ad esempio, se vuoi confrontare il Dipendente sulla base del nome, devi definire la sua logica sostituendo il metodo equals nella class Employee come di seguito:

 public class Employee { private Integer id; private String name; @Override public boolean equals(Object obj) { Employee other = (Employee) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } }