¿Cuál es la diferencia entre == vs equals () en Java?

Quería aclarar si entiendo esto correctamente:

  • == -> es una comparación de referencia, es decir, ambos objetos apuntan a la misma ubicación de memoria
  • .equals() -> evalúa la comparación de valores en los objetos

¿Estoy en lo correcto en mi comprensión?

En general, la respuesta a su pregunta es “sí”, pero …

  • .equals(...) solo comparará lo que está escrito para comparar, ni más ni menos.
  • Si una clase no anula el método equals, entonces adopta de manera predeterminada el método equals(Object o) de la clase padre más cercana que ha anulado este método.
  • Si no hay clases principales que hayan proporcionado una anulación, adopta de forma predeterminada el método de la clase primaria principal, Objeto, por lo que le queda el método Object#equals(Object o) . Según la API Object, esto es lo mismo que == ; es decir, devuelve verdadero si y solo si ambas variables se refieren al mismo objeto, si sus referencias son una y la misma. Por lo tanto, probará la igualdad de objetos y la igualdad funcional .
  • Siempre recuerde anular hashCode si anula equals para no “romper el contrato”. Según la API, el resultado devuelto por el método hashCode() para dos objetos debe ser el mismo si sus métodos equals muestran que son equivalentes. Lo contrario no es necesariamente cierto.

Con respecto a la clase String:

El método equals () compara el “valor” dentro de las instancias String (en el montón), independientemente de si las dos referencias a objetos se refieren a la misma instancia String o no. Si dos referencias a objetos de tipo String hacen referencia a la misma instancia de String, ¡genial! Si las dos referencias de objeto hacen referencia a dos instancias de cadena diferentes … no hace la diferencia. Es el “valor” (es decir: el contenido de la matriz de caracteres) dentro de cada instancia de String que se está comparando.

Por otro lado, el operador “==” compara el valor de dos referencias de objeto para ver si se refieren a la misma instancia de Cadena . Si el valor de ambas referencias a objetos “se refiere a” la misma instancia de Cadena, entonces el resultado de la expresión booleana sería “verdadero” … duh. Si, por otro lado, el valor de ambas referencias a objetos “se refiere a” diferentes instancias de Cadena (aunque ambas instancias de Cadena tienen “valores” idénticos, es decir, el contenido de las matrices de caracteres de cada instancia de Cadena es el mismo) el resultado de la expresión booleana sería “falso”.

Al igual que con cualquier explicación, deja que se hunda.

Espero que esto aclare las cosas un poco.

Existen algunas pequeñas diferencias según se trate de “primitivos” o “tipos de objetos”; lo mismo puede decirse si se trata de miembros “estáticos” o “no estáticos”; también puedes mezclar todo lo anterior …

Aquí hay un ejemplo (puede ejecutarlo):

 public final class MyEqualityTest { public static void main( String args[] ) { String s1 = new String( "Test" ); String s2 = new String( "Test" ); System.out.println( "\n1 - PRIMITIVES "); System.out.println( s1 == s2 ); // false System.out.println( s1.equals( s2 )); // true A a1 = new A(); A a2 = new A(); System.out.println( "\n2 - OBJECT TYPES / STATIC VARIABLE" ); System.out.println( a1 == a2 ); // false System.out.println( a1.s == a2.s ); // true System.out.println( a1.s.equals( a2.s ) ); // true B b1 = new B(); B b2 = new B(); System.out.println( "\n3 - OBJECT TYPES / NON-STATIC VARIABLE" ); System.out.println( b1 == b2 ); // false System.out.println( b1.getS() == b2.getS() ); // false System.out.println( b1.getS().equals( b2.getS() ) ); // true } } final class A { // static public static String s; A() { this.s = new String( "aTest" ); } } final class B { private String s; B() { this.s = new String( "aTest" ); } public String getS() { return s; } } 

Puede comparar las explicaciones de “==” (operador de igualdad) y “.equals (…)” (método en la clase java.lang.Object) a través de estos enlaces:

La diferencia entre == y equals me confundió por algún tiempo hasta que decidí echarle un vistazo más de cerca. Muchos de ellos dicen que para comparar cadenas debes usar equals y not == . Espero en esta respuesta ser capaz de decir la diferencia.

La mejor manera de responder a esta pregunta es haciéndose algunas preguntas. así que comencemos:

¿Cuál es el resultado del siguiente progtwig?

 String mango = "mango"; String mango2 = "mango"; System.out.println(mango != mango2); System.out.println(mango == mango2); 

si usted dice,

 false true 

Diré que tienes razón, pero ¿por qué dijiste eso ? y si dices que la salida es,

 true false 

Diré que estás equivocado, pero aún así te preguntaré, ¿por qué crees que es correcto?

Ok, intentemos responder a esto:

¿Cuál es el resultado del siguiente progtwig?

 String mango = "mango"; String mango3 = new String("mango"); System.out.println(mango != mango3); System.out.println(mango == mango3); 

Ahora si dices,

 false true 

Diré que estás equivocado, pero ¿por qué está mal ahora ? el resultado correcto para este progtwig es

 true false 

Por favor, compare el progtwig anterior e intente pensar en ello.

De acuerdo. Ahora esto podría ayudar (lea esto: imprima la dirección del objeto , no es posible pero aún así podemos usarlo).

 String mango = "mango"; String mango2 = "mango"; String mango3 = new String("mango"); System.out.println(mango != mango2); System.out.println(mango == mango2); System.out.println(mango3 != mango2); System.out.println(mango3 == mango2); // mango2 = "mang"; System.out.println(mango+" "+ mango2); System.out.println(mango != mango2); System.out.println(mango == mango2); System.out.println(System.identityHashCode(mango)); System.out.println(System.identityHashCode(mango2)); System.out.println(System.identityHashCode(mango3)); 

¿puede tratar de pensar en la salida de las últimas tres líneas en el código anterior: para mí, ideone imprimió esto ( puede consultar el código aquí ):

 false true true false mango mango false true 17225372 17225372 5433634 

Oh! Ahora ves que identityHashCode (mango) es igual a identityHashCode (mango2) Pero no es igual a identityHashCode (mango3)

Aunque todas las variables de cadena – mango, mango2 y mango3 – tienen el mismo valor, que es “mango”, identityHashCode() aún no es el mismo para todos.

Ahora intenta descomentar esta línea // mango2 = "mang"; y ejecutarlo de nuevo esta vez verá que los tres identityHashCode() son diferentes. Hmm eso es una sugerencia útil

sabemos que si hashcode(x)=N y hashcode(y)=N => x is equal to y

No estoy seguro de cómo funciona Java internamente, pero supongo que esto es lo que sucedió cuando dije:

 mango = "mango"; 

java creó una cadena "mango" que fue apuntada (referenciada) por la variable mango algo así

 mango ----> "mango" 

Ahora en la siguiente línea cuando dije:

 mango2 = "mango"; 

En realidad, reutilizó la misma cadena "mango" que se parece a esto

 mango ----> "mango" <---- mango2 

Tanto mango como mango2 apuntan a la misma referencia Ahora cuando dije

 mango3 = new String("mango") 

En realidad, creó una referencia completamente nueva (cadena) para "mango". que se ve algo como esto,

 mango -----> "mango" <------ mango2 mango3 ------> "mango" 

y es por eso que cuando mango == mango2 los valores para mango == mango2 , salió true . y cuando saqué el valor de mango3 == mango2 , salió false (incluso cuando los valores eran los mismos).

y cuando descomentó la línea // mango2 = "mang"; De hecho, creó una cadena "mang" que convirtió nuestro gráfico así:

 mango ---->"mango" mango2 ----> "mang" mango3 -----> "mango" 

Es por eso que identityHashCode no es lo mismo para todos.

Espero que esto les ayude chicos. En realidad, quería generar un caso de prueba donde == falla y es igual a () pasar. Por favor, siéntase libre de comentar y dejarme saber si estoy equivocado.

El operador == prueba si dos variables tienen las mismas referencias (también conocido como puntero a una dirección de memoria) .

 String foo = new String("abc"); String bar = new String("abc"); if(foo==bar) // False (The objects are not the same) bar = foo; if(foo==bar) // True (Now the objects are the same) 

Mientras que el método equals () prueba si dos variables se refieren a objetos que tienen el mismo estado (valores) .

 String foo = new String("abc"); String bar = new String("abc"); if(foo.equals(bar)) // True (The objects are identical but not same) 

Saludos 🙂

Deberá anular la función de igualdad (junto con otras) para usar esto con clases personalizadas.

El método igual compara los objetos.

El operador binario == compara direcciones de memoria.

Both == y .equals () se refiere al mismo objeto si no anulas .equals ().

Es su deseo lo que quiere hacer una vez que anule .equals (). Puede comparar el estado del objeto invocado con el estado pasado en el objeto o simplemente puede llamar a super.equals ()

Solo recuerde que .equals(...) tiene que ser implementado por la clase que está tratando de comparar. De lo contrario, no hay mucho de un punto; la versión del método para la clase Object hace lo mismo que la operación de comparación: Object # equal .

La única vez que realmente desea usar el operador de comparación para objetos es si está comparando Enums. Esto se debe a que solo hay una instancia de un valor Enum a la vez. Por ejemplo, dada la enumeración

 enum FooEnum {A, B, C} 

Nunca tendrá más de una instancia de A a la vez, y lo mismo para B y C Esto significa que puedes escribir un método como ese:

 public boolean compareFoos(FooEnum x, FooEnum y) { return (x == y); } 

Y no tendrás problemas en absoluto.

  String w1 ="Sarat"; String w2 ="Sarat"; String w3 = new String("Sarat"); System.out.println(w1.hashCode()); //3254818 System.out.println(w2.hashCode()); //3254818 System.out.println(w3.hashCode()); //3254818 System.out.println(System.identityHashCode(w1)); //prints 705927765 System.out.println(System.identityHashCode(w2)); //prints 705927765 System.out.println(System.identityHashCode(w3)); //prints 366712642 if(w1==w2) // (705927765==705927765) { System.out.println("true"); } else { System.out.println("false"); } //prints true if(w2==w3) // (705927765==366712642) { System.out.println("true"); } else { System.out.println("false"); } //prints false if(w2.equals(w3)) // (Content of 705927765== Content of 366712642) { System.out.println("true"); } else { System.out.println("false"); } //prints true 

== es un operador e equals() es un método .

Los operadores generalmente se usan para comparaciones de tipos primitivos y, por lo tanto, == se usa para la comparación de direcciones de memoria y el método equals() se usa para comparar objetos .

El operador ==:

El == es un operador relacional en Java que se usa para comparar dos operandos. Se usa para determinar si los dos operandos son iguales o no. Usando el operador ==, puede comparar cualquier tipo primitivo como int, char, float y Booleans. Después de la comparación, el operador == devuelve un valor booleano. Si los dos operandos son iguales, el operador == devuelve un valor verdadero. Sin embargo, si los dos operandos no son iguales, devuelve un valor falso. Cuando se utiliza con objetos, el operador == compara las dos referencias de objeto y determina si se refieren a la misma instancia.

El método .equals ()

equals () es un método disponible en la clase String que se usa para comparar dos cadenas y determinar si son iguales. Este método devuelve un valor booleano como resultado de la comparación. Si las dos cadenas contienen los mismos caracteres en el mismo orden, el método equals () devuelve verdadero. De lo contrario, devuelve un valor falso.

Por ejemplo:

http://goo.gl/Sa3q5Y

“==” en realidad están comparando las dos referencias de objetos para ver si apuntan al mismo objeto.

“igual”, que es una “comparación profunda” que compara los valores reales de la cadena.

También tenga en cuenta que .equals() normalmente contiene == para las pruebas ya que esto es lo primero que desea probar si desea probar si dos objetos son iguales.

Y == realmente mira valores para tipos primitivos, para objetos comprueba la referencia.

Cuando evalúa el código, está muy claro que (==) se compara de acuerdo con la dirección de la memoria, mientras que igual (Objeto o) compara hashCode () de las instancias. Es por eso que se dice que no rompa el contrato entre equals () y hashCode () si no enfrenta sorpresas más adelante.

  String s1 = new String("Ali"); String s2 = new String("Veli"); String s3 = new String("Ali"); System.out.println(s1.hashCode()); System.out.println(s2.hashCode()); System.out.println(s3.hashCode()); System.out.println("(s1==s2):" + (s1 == s2)); System.out.println("(s1==s3):" + (s1 == s3)); System.out.println("s1.equals(s2):" + (s1.equals(s2))); System.out.println("s1.equal(s3):" + (s1.equals(s3))); /*Output 96670 3615852 96670 (s1==s2):false (s1==s3):false s1.equals(s2):false s1.equal(s3):true */ 

La principal diferencia entre == y equals () es

1) == se usa para comparar primitivas.

Por ejemplo :

  String string1 = "Ravi"; String string2 = "Ravi"; String string3 = new String("Ravi"); String string4 = new String("Prakash"); System.out.println(string1 == string2); // true because same reference in string pool System.out.println(string1 == string3); // false 

2) equals () se usa para comparar objetos. Por ejemplo :

  System.out.println(string1.equals(string2)); // true equals() comparison of values in the objects System.out.println(string1.equals(string3)); // true System.out.println(string1.equals(string4)); // false 

== puede usarse en muchos tipos de objetos pero puede usar Object.equals para cualquier tipo, especialmente Strings y Google Map Markers.

== operador siempre se compara la referencia. Pero en caso de

método equals ()

Depende de la implementación si se reemplaza el método de igual que se compara el objeto en la implementación básica dada en el método reemplazado.

  class A { int id; String str; public A(int id,String str) { this.id=id; this.str=str; } public static void main(String arg[]) { A obj=new A(101,"sam"); A obj1=new A(101,"sam"); obj.equals(obj1)//fasle obj==obj1 // fasle } } 

en el código anterior, tanto el objeto obj como el obj1 contienen los mismos datos, pero la referencia no es la misma, por lo que devuelve false y == también. pero si reemplazamos el método es igual a

  class A { int id; String str; public A(int id,String str) { this.id=id; this.str=str; } public boolean equals(Object obj) { A a1=(A)obj; return this.id==a1.id; } public static void main(String arg[]) { A obj=new A(101,"sam"); A obj1=new A(101,"sam"); obj.equals(obj1)//true obj==obj1 // fasle } } 

saber comprobar que devolverá verdadero y falso para el mismo caso, solo hemos anulado

es igual al método.

compara objeto en básico de contenido (id) de objeto

pero ==

aún comparar referencias de objetos.

 public class StringPool { public static void main(String[] args) { String s1 = "Cat";// will create reference in string pool of heap memory String s2 = "Cat"; String s3 = new String("Cat");//will create a object in heap memory // Using == will give us true because same reference in string pool if (s1 == s2) { System.out.println("true"); } else { System.out.println("false"); } // Using == with reference and Object will give us False if (s1 == s3) { System.out.println("true"); } else { System.out.println("false"); } // Using .equals method which refers to value if (s1.equals(s3)) { System.out.println("true"); } else { System.out.println("False"); } } } 

—- Salida —– verdadero falso verdadero

Puede valer la pena agregar que para los objetos de la envoltura para los tipos primitivos, es decir, Int, Long, Double – == se devolverá verdadero si los dos valores son iguales.

 Long a = 10L; Long b = 10L; if (a == b) { System.out.println("Wrapped primitives behave like values"); } 

Para contrastar, poner los dos Longs anteriores en dos ArrayLists separados, equivale a considerarlos iguales, pero == no.

 ArrayList c = new ArrayList<>(); ArrayList d = new ArrayList<>(); c.add(a); d.add(b); if (c == d) System.out.println("No way!"); if (c.equals(d)) System.out.println("Yes, this is true."); 

El grupo de cadenas (también conocido como internado ) y el grupo de enteros difuminan aún más la diferencia, y pueden permitirte usar == para objetos en algunos casos en lugar de .equals

Esto puede darle un mayor rendimiento (?), A costa de una mayor complejidad.

P.ej:

 assert "ab" == "a" + "b"; Integer i = 1; Integer j = i; assert i == j; 

Equivalencia de complejidad: lo siguiente puede sorprenderlo:

 assert new String("a") != new String("a"); Integer i = 128; Integer j = 128; assert i != j; 

Te aconsejo que te mantengas alejado de tal micro-optimización, y siempre uses .equals para objetos, y == para primitivos:

 assert (new String("a")).equals(new String("a")); Integer i = 128; Integer j = 128; assert i.equals(j); 

Básicamente, == compara si dos objetos tienen la misma referencia en el montón, por lo tanto, a menos que dos referencias estén vinculadas al mismo objeto, esta comparación será falsa.

equals() es un método heredado de la clase Object . Este método por defecto compara si dos objetos tienen la misma referencia. Significa:

object1.equals(object2) <=> object1 == object2

Sin embargo, si desea establecer la igualdad entre dos objetos de la misma clase, debe anular este método. También es muy importante anular el método hashCode() si ha reemplazado equals() .

Implementar hashCode() cuando se establece la igualdad es parte del Contrato de objetos Java. Si está trabajando con colecciones y no ha implementado hashCode() , podrían pasar cosas extrañas:

 HashMap cats = new HashMap<>(); Cat cat = new Cat("molly"); cats.put(cat, "This is a cool cat"); System.out.println(cats.get(new Cat("molly")); 

null se imprimirá después de ejecutar el código anterior si no ha implementado hashCode() .

En general, los operadores equals () y “==” en Java se usan para comparar objetos para verificar la igualdad, pero estas son algunas de las diferencias entre los dos:

La diferencia principal entre el método .equals () y el operador == es que uno es un método y el otro es el operador.

Podemos usar == operadores para la comparación de referencia (comparación de direcciones) y el método .equals () para la comparación de contenido. En palabras simples, == verifica si ambos objetos apuntan a la misma ubicación de memoria mientras que .equals () evalúa la comparación de valores en los objetos. Si una clase no anula el método equals, entonces por defecto usa el método equals (Object o) de la clase principal más cercana que ha anulado este método. Ver esto para más detalles

Como Java no admite la sobrecarga del operador, == se comporta de forma idéntica para todos los objetos, pero equals () es el método, que se puede anular en Java y la lógica para comparar objetos se puede cambiar en función de las reglas comerciales.

La principal diferencia entre == y igual en Java es que “==” se usa para comparar primitivas, mientras que se recomienda el método igual () para verificar la igualdad de objetos.

La comparación de cadenas es un escenario común de usar tanto == como el método igual. Como la clase java.lang.String anula el método equals, devuelve true si dos objetos String contienen el mismo contenido, pero == solo devolverá true si dos referencias apuntan al mismo objeto.

Aquí hay un ejemplo de comparación de dos cadenas en Java para la igualdad usando el método == y equals () que despejará algunas dudas:

 public class TEstT{ public static void main(String[] args) { String text1 = new String("apple"); String text2 = new String("apple"); //since two strings are different object result should be false boolean result = text1 == text2; System.out.println("Comparing two strings with == operator: " + result); //since strings contains same content , equals() should return true result = text1.equals(text2); System.out.println("Comparing two Strings with same content using equals method: " + result); text2 = text1; //since both text2 and text1d reference variable are pointing to same object //"==" should return true result = (text1 == text2); System.out.println("Comparing two reference pointing to same String with == operator: " + result); } }