¿Por qué método equals() cuando tenemos == operador?

Question

Cuando veo la implementación del método equals(), no hace más que lo que hace ==. Entonces mi pregunta es ¿cuál fue la necesidad de tener esto como método separado cuando tenemos el operador == que hace el mismo trabajo?

Answer 1

Usted no puede sobrecargar el operador ==, pero puede dar prioridad equals(Object) si quieres que se comporte de manera diferente por parte del operador ==, es decir, no se pueden comparar las referencias, pero en realidad comparar los objetos (por ejemplo, utilizando todos o algunos de sus campos).

Además, si sobrescribe equals(Object), también puede ver hashCode(). Estos dos métodos deben ser compatibles (es decir, dos objetos que son iguales según equals(Object) deben tener el mismo hashCode()), de lo contrario se producirán todo tipo de errores extraños (por ejemplo, al agregar los objetos a un conjunto o mapa).

Answer 2

== compara el objeto referencias, y pregunta si las dos referencias son las mismas.

equals() compara el objeto contenidos, y pregunta si los objetos representan el mismo concepto.

Answer 3

"cadena" == "cadena" volverá falsas .equals "cadena" ("cadena") devolverá verdadero

Con o1 == o2 se compara que el objeto 1 es el mismo objeto de O2 (referencia)

con o1.equals (O2), en función del objeto del método es igual está anulado y no se ha implementado con algo como "volver o1 == o2"

Para exemple crear instancias 2 Set Estos 2 objetos configurados son 2 objetos diferentes, puede agregar diferentes elementos en cualquiera de ellos. set1 == set2 siempre devolverá false pero set1.equals (set2) eventualmente devolverá true si el set2 contiene exactamente los mismos elementos que set1 ... y porque el método equals es anulado en la clase Set ...

es igual a la ejecución de SET es:

 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 
    } 

Answer 4

que se han hecho de manera de hacer esto posible:

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 

Si marca la fuente de String#equals(), verá que se ha anulado el Object#equals() de forma adecuada para comparar el conjunto de caracteres internos de cada uno (el valor real). Muchas otras clases tienen este método anulado también.

Answer 5

Hay una diferencia muy importante entre los dos.

"==" compara instancias de objetos. La implementación predeterminada equals() hace esto, también.Por favor, ejecute & analizar el siguiente ejemplo de código:

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

Como se puede ver, "==" devolverá falso (los objetos son dos instancias diferentes de la persona), mientras que los iguales volverán verdadera (porque definimos que 2 las personas son iguales cuando tienen el mismo nombre)

Answer 6

En caso de primitivas, los == operador comprueba si dos valores son los mismos.
Si no son primitivas, comprueba si son dos punteros (o referencias) apuntando a la misma instancia de un objeto.

El método equals() realiza una comprobación personalizada, que está en Object la comprobación de la referencia, mediante el uso de ==. Pero en otras clases, a veces equals() se anula _{(no sé si este es un participio pasado correcto)}. equals() tiene que verificar el contenido .

Así, por ejemplo:

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

Pero si tenemos que no son primitivas

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 

Así que, ¿por qué str0.equals(str1) vuelve true? Porque la clase String tiene una anulación de equals(). Y en ese método no verifica si son iguales al hacer return this == obj; Pero en ese método, hay una verificación completa. No sé qué método que utilizan para comparar las dos cadenas, pero aquí hay dos maneras posibles:

• generar a partir de la cadena de los dos un código hash y comprobar si son iguales (int == int)
• Verificando carácter por personaje si son iguales.

Así que espero que esto esté claro ahora.

Answer 7

== operador se utiliza para comparar las referencias.
El método equals() se define sobre la definición del objeto.

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() 

volvería falsa que indica que los dos los perros tienen dos diferentes objetos collar (artículos) .they no comparten el mismo collar de.

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

retorno cierto si el collar se define como [Collar son los mismos si el color de collar son mismo] los dos perros tener el mismo collar de color.

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

Answer 8

en Java operador de igualdad (==) opera en los datos de dos variables si los operandos son de tipos de datos primitivos.Pero si los operandos son objetos, java los compara usando referencias porque no tiene manera de averiguar para comparar en qué campo o campos del objeto.

Así que solo hay una forma de comparar basándose en campos definidos por el usuario y redefiniendo los métodos equals(), ya que el operador igual (==) no puede anularse en java ya que java no admite anulación de operador .

Como ejemplo, si se desea comparar Empleado sobre la base del nombre es necesario definir que es la lógica de primer orden es igual método en la clase de empleado de la siguiente manera:

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


}