qual è la differenza tra == operator ed equals ()? (con hashcode () ???)

Stavo imparando hashcode in modo più approfondito e ho capito che:

1. Se si esegue l’override di equals (), è necessario sovrascrivere anche hashcode ().

2. Per trovare se 2 oggetti sono lo stesso object, utilizzare l’operatore ==

Dati questi 2 fattori, in Java stavo assumendo che quando l’ == operator è usato per confrontare se 2 istanze sono uguali o no,

 if(object1 == object2) 

sta facendo davvero

 if(object1.hashcode() == object2.hashcode()) 

Ma sembra che ho sbagliato eseguendo il test qui sotto.

 public class Main { public static void main(String[] args){ Obj1 one = new Obj1(); Obj1 two = new Obj1(); //is this calling hashCode() in backend??? if(one == two) { System.out.println("same"); } else { System.out.println("nope"); } //this is of course return true if(one == one) { System.out.println("one and one is same"); } } } class Obj1 { @Override public int hashCode() { System.out.println("hashCode() is called"); return 111; } @Override public boolean equals(Object another) { System.out.println("equals() is called"); return false; } } 

Secondo il test che usa l’ == operator e vede se equals() è chiamato e non lo era.

Quindi la mia domanda è se l’ == operator può essere usato per confrontare se l’object è uguale o no, qual è il punto di sovrascrivere il quals() e quals() e hashCode() per il confronto? L’ == operator non fa già il lavoro?

riferimento:

Overriding hashCode () – è abbastanza buono?

http://mindprod.com/jgloss/hashcode.html

http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Object.html#equals(java.lang.Object)

l’operatore == determina se 2 riferimenti puntano allo stesso object.

Così

  Object o1 = new Object(); Object o2 = o1; o1 == o2; //true o2 = new Object(); o1 == o2 // false 

il metodo Object.equals () è “come faccio a determinare se 2 riferimenti a oggetti, che non sono lo stesso object, sono uguali?”

Se due riferimenti puntano allo stesso object, entrambi

 o1 == o2 o1.equals(o2) 

dovrebbe essere vero

Ma se o1 e o2 non sono lo stesso object, potrebbero comunque essere logicamente uguali. Per ogni data class, equals dipende dalla semantica dietro l’object. Ad esempio, si consideri una class in cui field1 e field2 sono impostati dall’utente, ma field3 è calcolato e ha un elemento casuale al suo calcolo. Potrebbe avere senso definire gli equals in questo caso per dipendere solo da field1 e field2, e non field3. Ecco perché è necessario essere uguali.

== è id quadro.

.equals() è l’uguaglianza.

.equals() usa come valore predefinito == (proprio come hashCode() imposta di default System.identityHashCode() ma è ansible sovrascriverli se c’è un modo più significativo per controllare l’uguaglianza. In genere si tratta di una sorta di uguaglianza “strutturale”. cioè: sono tutti pezzi di this .equal() a tutti i pezzi di that ?

Se non hai già una copia; compra una copia di Effective Java di Joshua Bloch.

Questo è di fatto il riferimento per gli sviluppatori Java e ha molte informazioni su questo (e molti altri) argomenti.

== (usato sugli oggetti piuttosto che sui valori primitivi) verifica se 2 oggetti sono effettivamente lo stesso object; confronta se i puntatori stanno effettivamente puntando alla stessa posizione di memoria.

.equals() è definito dall’object stesso.

 String s1 = new String("Hello"); String s2 = new String("Hello"); boolean b1 = ( s1 == s2 ) ; // false: s1 and s2 point to different objects boolean b2 = ( s1.equals(s2) ) ; // true: s1 and s2 both represent the same // piece of text - "Hello" 

.hashCode() è un trucco di ottimizzazione (nella maggior parte dei suoi usi, comunque). Un sacco di codice nelle librerie standard presuppone che se o1.equals(o2)==true allora o1.hashCode()==o2.hashCode() e che se o1.hashCode()!=o2.hashCode() quindi o1.equals(o2)==false per funzionare più velocemente.

L’esempio più ovvio di tale ottimizzazione è la class HashMap . Ciò rende il recupero degli oggetti utilizzando una chiave molto veloce, ma si interrompe gravemente se hashCode ed equals non funzionano correttamente per gli elementi chiave. In effetti, questo è uno dei motivi per cui la class String è immutabile: se tu fossi in grado di modificare una String (e così cambiare il suo hashCode) mentre quella String era la chiave in una HashMap, allora non saresti mai in grado di trovarla , dato che finiresti per cercarlo nel posto sbagliato!

Altre risposte consigliano Java efficace di Joshua Bloch. Se stai facendo domande del genere, allora ora è il momento giusto nella tua carriera per comprare il libro e leggerlo copertinalmente. Vale anche la pena di rileggerlo tra un anno o due, quando ne avrai dimenticato un po ‘e ne avrai di più …

La maggior parte ha già una risposta, quindi ecco un altro esempio illuminante:

 String s1 = "foo"; String s2 = "foo"; System.out.println(s1 == s2); // true, because same reference (string pool) String s3 = new String("foo"); String s4 = new String("foo"); System.out.println(s3 == s4); // false, because different reference System.out.println(s3.equals(s4)); // true, because same value 

== operatore -> verifica che i riferimenti meteo 2 puntino allo stesso object o meno. Se lo stesso restituisce vero altrimenti falso.

equals( ) -> controlla sia riferimento che object di stato. Ascoltare lo stato significa dati object. In questo ognuno è vero, restituisce il vero. Altrimenti falso. Ma dobbiamo sovrascrivere equals( ) nel nostro object definito dall’utente e scrivere il codice appropriato.

Hashcode( ) -> hashCode di un object rappresenta solo un numero casuale che può essere utilizzato da JVM durante il salvataggio / aggiunta di oggetti in Hashset, Hashtables o Hashmap.

Esempio di hashcode()

 class TestHasChode { int i; TestHasChode(int i) { this.i = i; } public static void main(String arg[]) { //before overriding hashcode() TestHasChode t1 = new TestHasChode(100); TestHasChode t2 = new TestHasChode(110); System.out.println(t1); //[email protected] System.out.println(t2); //[email protected] TestHasChode t3 = new TestHasChode(100); TestHasChode t4 = new TestHasChode(100); System.out.println(t3); //[email protected] System.out.println(t4); //[email protected] /*hashCode() of Object class implemented to return hashCode based on address of an object, but based on our requirement we can override hashCode() to generate our own numbers as hashCodes*/ //after overriding hashcode() System.out.println(t3); //[email protected] System.out.println(t4); //[email protected] } public int hashCode(){ return i; } } -->Example of equals()method class Student { String name; int rollno; Student(String name,int rollno) { this.name = name; this.rollno = rollno; } public static void main(String arg[]) { //before overrideng equals method Student s1 = new Student ("raju", 101); Student s2 = new Student ("giri", 102); Student s3 = new Student ("giri", 102); System.out.println(s1.equals(s2));//false System.out.println(s2.equals(s3));//false //after overriding equals method System.out.println(s1.equals(s2));//false System.out.println(s2.equals(s3));//true-->hear overriding equals() checks state.so it is true. //in string variables comparisition String s4="hello"; String s5=new String("hello"); String s6=new String("hello"); System.out.println(s4.equals(s5));//true--> because String class containg overridden equals method System.out.println(s5.equals(s6));//true-->even though differnet object reference but String class containg overridden equals method } public boolean equals(Object obj){ String name1 = this.name; int rollno1 = this.rollno; Student s2 = (Student)obj; String name2 = s2.name; int rollno2 = s2.rollno; if(name1.equals(name2) && rollno1 == rollno2){ return true;} else{ return false;} } }