Compara dos objetos con .equals () y == operador

Construí una clase con un campo String . Luego creé dos objetos y tengo que compararlos usando == operator y .equals() también. Esto es lo que hice:

 public class MyClass { String a; public MyClass(String ab) { a = ab; } public boolean equals(Object object2) { if(a == object2) { return true; } else return false; } public boolean equals2(Object object2) { if(a.equals(object2)) { return true; } else return false; } public static void main(String[] args) { MyClass object1 = new MyClass("test"); MyClass object2 = new MyClass("test"); object1.equals(object2); System.out.println(object1.equals(object2)); object1.equals2(object2); System.out.println(object1.equals2(object2)); } } 

Después de comstackr, muestra dos veces falso como resultado. ¿Por qué es falso si los dos objetos tienen los mismos campos, “prueba”?

== compara referencias de objetos, comprueba si los dos operandos apuntan al mismo objeto (no objetos equivalentes , el mismo objeto).

Si desea comparar cadenas (para ver si contienen los mismos caracteres), necesita comparar las cadenas usando equals .

En su caso, si dos instancias de MyClass realmente se consideran iguales si las cadenas coinciden, entonces:

 public boolean equals(Object object2) { return object2 instanceof MyClass && a.equals(((MyClass)object2).a); } 

… pero generalmente si define una clase, hay más en la equivalencia que la equivalencia de un solo campo ( a en este caso).


Nota al hashCode : si anula equals , casi siempre tendrá que anular hashCode . Como dice en los equals JavaDoc :

Tenga en cuenta que generalmente es necesario anular el método hashCode siempre que se anule este método, a fin de mantener el contrato general para el método hashCode , que establece que los objetos iguales deben tener códigos hash iguales.

debes anular iguales

  public boolean equals (Object obj) { if (this==obj) return true; if (this == null) return false; if (this.getClass() != obj.getClass()) return false; // Class name is Employ & have lastname Employe emp = (Employee) obj ; return this.lastname.equals(emp.getlastname()); } 

Parece que equals2 solo llama a equals , por lo que dará los mismos resultados.

Su método equals2() siempre devolverá lo mismo que equals() !!

Tu código con mis comentarios:

 public boolean equals2(Object object2) { // equals2 method if(a.equals(object2)) { // if equals() method returns true return true; // return true } else return false; // if equals() method returns false, also return false } 

La función de sobrescritura es igual a () es incorrecta. El objeto “a” es una instancia de la clase String y “object2” es una instancia de la clase MyClass . Son clases diferentes, por lo que la respuesta es “falsa”.

La mejor forma de comparar 2 objetos es convirtiéndolos en cadenas json y comparando las cadenas, es la solución más fácil cuando se trata de objetos nesteds complicados, campos y / u objetos que contienen matrices.

muestra:

 import com.google.gson.Gson; Object a = // ...; Object b = //...; String objectString1 = new Gson().toJson(a); String objectString2 = new Gson().toJson(b); if(objectString1.equals(objectString2)){ //do this } 

Las declaraciones a == object2 y a.equals(object2) both siempre devolverán false porque a es una string mientras que object2 es una instancia de MyClass

Su implementación debe gustarle:

 public boolean equals2(Object object2) { if(a.equals(object2.a)) { return true; } else return false; } 

Con esta implementación, ambos métodos funcionarían.

Su clase podría implementar la interfaz Comparable para lograr la misma funcionalidad. Su clase debe implementar el método compareTo () declarado en la interfaz.

 public class MyClass implements Comparable{ String a; public MyClass(String ab){ a = ab; } // returns an int not a boolean public int compareTo(MyClass someMyClass){ /* The String class implements a compareTo method, returning a 0 if the two strings are identical, instead of a boolean. Since 'a' is a string, it has the compareTo method which we call in MyClass's compareTo method. */ if(this.a.compareTo(someMyClass.a) == 0) return 0; return 1; } public static void main(String[] args){ MyClass object1 = new MyClass("test"); MyClass object2 = new MyClass("test"); if(object1.compareTo(object2) == 0){ System.out.println("true"); } else{ System.out.println("false"); } } } 

el tipo de devolución de object.equals ya es booleano. no hay necesidad de envolverlo en un método con twigs. entonces si quieres comparar 2 objetos simplemente compáralos:

 boolean b = objectA.equals(objectB); 

b ya es verdadero o falso.

Cuando usamos ==, la referencia del objeto no se compara con los objetos reales. Necesitamos anular el método de igualdad para comparar objetos de Java.

Alguna información adicional C ++ tiene el operador sobrecargando y Java no proporciona al operador una carga excesiva. También otras posibilidades en Java son implementar la interfaz de comparación, que define un método compareTo.

La interfaz del comparador también se usa para comparar dos objetos

El operador “==” devuelve verdadero solo si las dos referencias apuntan al mismo objeto en la memoria. El método equals () por otro lado devuelve verdadero basado en el contenido del objeto.

Ejemplo:

 String personalLoan = new String("cheap personal loans"); String homeLoan = new String("cheap personal loans"); //since two strings are different object result should be false boolean result = personalLoan == homeLoan; System.out.println("Comparing two strings with == operator: " + result); //since strings contains same content , equals() should return true result = personalLoan.equals(homeLoan); System.out.println("Comparing two Strings with same content using equals method: " + result); homeLoan = personalLoan; //since both homeLoan and personalLoand reference variable are pointing to same object //"==" should return true result = (personalLoan == homeLoan); System.out.println("Comparing two reference pointing to same String with == operator: " + result); 

Salida: Comparando dos cadenas con == operador: falso Comparando dos cadenas con el mismo contenido usando el método equals: true Comparando dos referencias que apuntan a la misma cadena con == operator: true

También puede obtener más detalles en el enlace: http://javarevisited.blogspot.in/2012/12/difference-between-equals-method-and-equality-operator-java.html?m=1

Aquí la salida será falsa, falsa porque en la primera statement de Sopln está tratando de comparar una varible de tipo cadena del tipo Myclass con el otro tipo MyClass y permitirá porque ambos son tipo Objeto y ha usado el oprerator “==” que verificará el valor de la variable de referencia que contiene la memoria real, no las contiendas reales dentro de la memoria. En el segundo sopln también es lo mismo que está llamando nuevamente a.equals (object2) donde a es varible dentro de object1. Háganme saber sus hallazgos sobre esto.

Si no necesita personalizar la función predeterminada aString (), otra forma es anular el método toString (), que devuelve todos los atributos que se compararán. luego compare con la salida String () de dos objetos. Genere el método toString () utilizando IntelliJ IDEA IDE, que incluye el nombre de clase en la cadena.

 public class Greeting { private String greeting; @Override public boolean equals(Object obj) { if (this == obj) return true; return this.toString().equals(obj.toString()); } @Override public String toString() { return "Greeting{" + "greeting='" + greeting + '\'' + '}'; } } 

EN el siguiente código está llamando al método reemplazado .equals ().

public boolean equals2 (Object object2) {if (a.equals (object2)) {// Aquí está llamando al método overriden, es por eso que obtiene false 2 veces. devolver verdadero; } else return falso; }

  /** Comparing two or more variables. Here the two items are compared and it will return a boolean true or false. * * @return equals */ public boolean equals(Object item) { String emp1 = this.toString(); String emp2 = item.toString(); return emp1.equals(emp2); } @Override //In case you have more than one variable. public String toString() { return a + b; } // a and b represent the variables to display.