Yo estaba aprendiendo hashcode en más profundidad y pensé que:

1. Si reemplaza equals(), se debe reemplazar hashcode ().

2. Para encontrar si 2 objetos son el mismo objeto, utilice el operador = =

Con esos 2 factores, en Java estaba asumiendo que cuando == operator se utiliza para comparar si 2 casos son los mismos o no,

if(object1 == object2)

está haciendo en realidad

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

Pero parece que me equivoqué por la ejecución de la prueba a continuación.

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

De acuerdo a la prueba que utiliza == operator y ver si equals() se llama y no lo fue.

Así que mi pregunta es si == operator puede utilizar para comparar si el objeto es el mismo o no, ¿cuál es el punto de primordial equals() y hashCode() método para la comparación? No == operator hacer el trabajo ya?

referencia:

Primordial hashCode() – este es lo suficientemente bueno?

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

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

chicos gracias por la explicación. Por eso me gusta stackoverflow. Mucha de la gente inteligente que puede describir y dar buen ejemplo, mucho mejor que la documentación oficial que proporciona una definición única 😀

OriginalEl autor masato-san | 2010-12-22

6 Comentarios

  1. 5

    el operador == determina si 2 referencias apuntan al mismo objeto.

    Así

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

    el Objeto.equals() el método es «¿cómo puedo determinar si 2 las referencias a objetos, que no son el mismo objeto, son iguales?»

    Si dos referencias apuntan al mismo objeto, tanto

    o1 == o2 
    o1.equals(o2) 

    debe ser cierto.

    Pero si o1 y o2 no son el mismo objeto, que todavía podría ser igual forma lógica. De cualquier clase, igual depende de la semántica detrás del objeto. Por ejemplo, considere una clase donde campo1 y campo2 son establecidos por el usuario, pero field3 se calcula y se tiene un elemento aleatorio para su cálculo. Podría tener sentido para definir equivale en este caso a depender solo de campo1 y campo2, y no campo3. Es por eso que igual es necesario.

    Así que cuando hashcode ()? Es nuestra decisión de tener hashcode utilizado dentro de equals() método para la comparación?
    hashcode es utilizado por los diversos hash a partir de colecciones, como las de HashSets. Es su decisión si desea utilizar hashcode en iguala, pero ser conscientes de que no es siempre el caso de que si 2 objetos devuelven el mismo hashcode, son iguales. Yo no lo haría.

    OriginalEl autor hvgotcodes

  2. 4

    == es la identidad.

    .equals() es la igualdad.

    .equals() por defecto usando sólo == (como hashCode() valores predeterminados para System.identityHashCode() pero se puede reemplazar si hay una manera más significativa para la verificación de la igualdad. Normalmente se trata de una especie de «estructural» de la igualdad. es decir: son todas las piezas de this .equal() a todas las piezas de that?

    OriginalEl autor Laurence Gonsalves

  3. 2

    Si usted no tiene una copia, comprar una copia de Efectivo de Java por Joshua Bloch.

    Este es el facto de referencia para los desarrolladores de Java y tiene un montón de información sobre este (y muchos otros) sujeto.

    Ir a la tienda de libros este fin de semana 😀 que sería mi navidad presente!
    me podría decir que las secciones de explicar estas cosas en ese libro?
    Tema 8 y tema 9 en el libro.

    OriginalEl autor Fortyrunner

  4. 2

    == de (utilizados en objetos más que en valores primitivos) si las pruebas de 2 objetos son en realidad el mismo objeto; compara si los punteros son realmente apuntando a la misma ubicación de memoria.

    .equals() se define por el objeto en sí.

    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() es una optimización truco (en la mayoría de sus usos, de todos modos). Un mucho de código en las bibliotecas estándar que hace la suposición de que si o1.equals(o2)==true luego o1.hashCode()==o2.hashCode() y que si o1.hashCode()!=o2.hashCode() luego o1.equals(o2)==false con el fin de trabajar más rápido.

    El más obvio ejemplo de este tipo de optimización es el HashMap clase. Esto hace que la recuperación de objetos utilizando una clave realmente rápido, pero rompe mal si hashCode y es igual no funcionan correctamente para que los elementos clave. De hecho, esta es una de las razones por las que la clase String es inmutable: si usted fuera capaz de modificar una Cadena (y, por tanto, cambiar su etiqueta), mientras que la Cadena fue la clave en un HashMap, entonces usted no será capaz de encontrar, ya que acabaría buscando en el lugar equivocado!

    Otras respuestas recomendamos Efectivos De Java por Joshua Bloch. Si usted está pidiendo a estas preguntas, entonces ahora es el momento perfecto en su carrera para comprar el libro y la lectura de tapa a tapa. También será que vale la pena volver a leer en un año o dos, cuando te han olvidado algunos de ellos y más de esto tendría sentido…

    OriginalEl autor Bill Michell

  5. 1

    La mayoría ya está contestada, por lo que esto es sólo otro ejemplo esclarecedor:

    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

    OriginalEl autor BalusC

  6. 0

    == operador –> comprueba el tiempo 2 referencias apuntan al mismo objeto o no. Si es el mismo que devolver true y false en caso contrario.

    equals( ) –> cheques de referencia y objeto de estado. Escuchar estatal de medios objeto de datos. En esto, cada uno es verdadero devuelve true. De lo contrario, false. Pero tenemos que reemplazar equals( ) en nuestro objeto definido por el usuario y escribir el código apropiado.

    Hashcode( ) –>código hash de un Objeto sólo representa un número aleatorio que puede ser utilizado por JVM, mientras que el ahorro/agregar Objetos en Hashsets, tablas hash o Hashmap.

    Ejemplo de 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;}  
    }        
    }

    OriginalEl autor voore vamshi

Dejar respuesta

Please enter your comment!
Please enter your name here