¿Cuál es la diferencia entre “.equals” y “==”?

Cambié profesores hoy y él dijo que usaba un código extraño para mí. (Dijo que es mejor usar .equals y cuando le pregunté por qué, respondió “¡porque lo es!”)

Así que aquí hay un ejemplo:

 if (o1.equals(o2)) { System.out.println("Both integer objects are the same"); } 

En lugar de a lo que estoy acostumbrado:

 if (o1 == o2) { System.out.println("Both integer objects are the same"); } 

Cuál es la diferencia entre los dos. ¿Y por qué es mejor su forma (usando .equals )?

Encontré esto en una búsqueda rápida pero realmente no puedo darle sentido a esa respuesta:

En Java, == siempre compara dos referencias (para no primitivas), es decir, comprueba si los dos operandos se refieren al mismo objeto.

Sin embargo, el método equals se puede anular, por lo que dos objetos distintos pueden ser iguales.

Por ejemplo:

 String x = "hello"; String y = new String(new char[] { 'h', 'e', 'l', 'l', 'o' }); System.out.println(x == y); // false System.out.println(x.equals(y)); // true 

Además, vale la pena tener en cuenta que dos constantes de cadena iguales (principalmente literales de cadena, pero también combinaciones de constantes de cadena mediante concatenación) terminarán refiriéndose a la misma cadena. Por ejemplo:

 String x = "hello"; String y = "he" + "llo"; System.out.println(x == y); // true! 

Aquí y son referencias a la misma cadena, porque y es una constante en tiempo de comstackción igual a "hello" .

El operador == compara si los objetos son la misma instancia . El orador de iguales () compara el estado de los objetos (por ejemplo, si todos los atributos son iguales). Incluso puede anular el método equals () para definirse a usted mismo cuando un objeto es igual a otro.

Si usted y yo entramos al banco, cada uno abre una cuenta nueva y cada depósito deposita $ 100, luego …

  1. myAccount.equals(yourAccount) es true porque tienen el mismo valor , pero
  2. myAccount == yourAccount es false porque no son la misma cuenta .

(Suponiendo las definiciones apropiadas de la clase Account , por supuesto. 😉

== es un operador. equals es un método definido en la clase Object

== comprueba si dos objetos tienen la misma dirección en la memoria y para la primitiva comprueba si tienen el mismo valor. El método de igualdad, por otra parte, comprueba si los dos objetos que se comparan tienen el mismo valor (dependiendo de cómo, por supuesto, el El método equals se ha implementado para los objetos. El método equals no se puede aplicar a las primitivas (lo que significa que si a es una primitiva a.equals (someobject) no está permitido, sin embargo se permite someobject.equals (a)).

== operador compara dos referencias de objeto para comprobar si se refieren a la misma instancia. Esto también volverá a ser cierto en una coincidencia exitosa. Por ejemplo

 public class Example{ public static void main(String[] args){ String s1 = "Java"; String s2 = "Java"; String s3 = new string ("Java"); test(Sl == s2) //true test(s1 == s3) //false }} 

el ejemplo anterior == es una comparación de referencia, es decir, ambos objetos apuntan a la misma ubicación de memoria

String equals () se evalúa como la comparación de valores en los objetos.

  public class EqualsExample1{ public static void main(String args[]){ String s = "Hell"; String s1 =new string( "Hello"); String s2 =new string( "Hello"); s1.equals(s2); //true s.equals(s1) ; //false }} 

ejemplo anterior Compara el contenido de las cadenas. Devolverá verdadero si la cadena coincide, de lo contrario devuelve falso.

En Java, cuando el operador “==” se usa para comparar 2 objetos, verifica si los objetos se refieren al mismo lugar en la memoria. EX:

 String obj1 = new String("xyz"); String obj2 = new String("xyz"); if(obj1 == obj2) System.out.println("obj1==obj2 is TRUE"); else System.out.println("obj1==obj2 is FALSE"); 

Aunque las cadenas tienen los mismos caracteres exactos (“xyz”), el código anterior realmente dará como resultado: obj1 == obj2 es FALSO

La clase Java String en realidad anula la implementación equals () predeterminada en la clase Object, y anula el método para que solo compruebe los valores de las cadenas, no sus ubicaciones en la memoria. Esto significa que si llama al método equals () para comparar 2 objetos String, entonces, siempre que la secuencia real de caracteres sea igual, ambos objetos se consideran iguales.

 String obj1 = new String("xyz"); String obj2 = new String("xyz"); if(obj1.equals(obj2)) System.out.printlln("obj1==obj2 is TRUE"); else System.out.println("obj1==obj2 is FALSE"); 

Este código dará como resultado lo siguiente:

obj1 == obj2 es VERDADERO

 public static void main(String[] args){ String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1.equals(s2)); //// System.out.println(s1 == s2); System.out.println("-----------------------------"); String s3 = "hello"; String s4 = "hello"; System.out.println(s3.equals(s4)); //// System.out.println(s3 == s4); } 

Aquí, en este código, puede comparar tanto ‘==’ como ‘.equals’

aquí .equals se usa para comparar los objetos de referencia y ‘==’ se usa para comparar el estado de los objetos.

(1) == se puede aplicar tanto para primitivos como para tipos de objetos, pero el método equals () solo se puede aplicar para tipos de objetos.

(2) == no se puede anular para la comparación de contenido, pero el método igual se puede anular para la comparación de contenido (por ejemplo, clase String, clases contenedoras, clases de colección).

(3) == da un error de tipo incomparable cuando intentas aplicar para tipos heterogéneos, donde el método igual devuelve falso.

El método equals( ) y el operador == realizan dos operaciones diferentes. El método equals( ) compara los caracteres dentro de un objeto String . El operador == compara dos referencias de objeto para ver si se refieren a la misma instancia. El siguiente progtwig muestra cómo dos objetos String diferentes pueden contener los mismos caracteres, pero las referencias a estos objetos no se compararán como iguales:

 // equals() vs == class EqualsNotEqualTo { public static void main(String args[]) { String s1 = "Hello"; String s2 = new String(s1); System.out.println(s1 + " equals " + s2 + " -> " + s1.equals(s2)); System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2)); } } 

La variable s1 refiere a la instancia de cadena creada por “Hello” . El objeto al que hace referencia s2 se crea con s1 como inicializador. Por lo tanto, los contenidos de los dos objetos String son idénticos, pero son objetos distintos. Esto significa que s1 y s2 no hacen referencia a los mismos objetos y, por lo tanto, no son == , como se muestra aquí en el resultado del ejemplo anterior:

 Hello equals Hello -> true Hello == Hello -> false 

Digamos que el operador “==” devuelve verdadero si ambos operandos pertenecen a un mismo objeto, pero cuando devolverá verdadero ya que no podemos asignarle a un solo objeto valores múltiples

 public static void main(String [] args){ String s1 = "Hello"; String s1 = "Hello"; // This is not possible to assign multiple values to single object if(s1 == s1){ // Now this retruns true } } 

Ahora, cuando esto sucede prácticamente hablando, si no ocurre, entonces ¿por qué esto es == compara la funcionalidad …?

Aquí hay una interpretación simple sobre su problema:

== (igual a) usado para evaluar la expresión aritmética

donde como

Método equals () utilizado para comparar cadenas

Por lo tanto, es mejor usar == para las operaciones numéricas y el método equals () para las operaciones relacionadas con Cadenas. Entonces, para la comparación de objetos, el método equals () sería la elección correcta.