diferencia - use equals java

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

Question

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 entendimiento?

Answer 1

El operador == comprueba 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 () comprueba 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 :-)

Answer 2

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

método igual ()

depende de la implementación si estamos anulados por el método igual al que compara el objeto en la implementación básica dada en el método anulado.

 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 objeto obj1 contienen los mismos datos pero la referencia no es la misma, por lo que igual devuelve false y == también. pero si anulamos el método 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
    }
 }

Sabemos que el registro de salida devolverá verdadero y falso para el mismo caso que solo anulamos

es igual al metodo

Se compara objeto en base de contenido (id) de objeto.

pero ==

Sigo comparando referencias de objeto.

Answer 3

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 tienes anulaciones equals() .

Implementar hashCode() al establecer la igualdad es parte del Contrato de Objeto de Java. Si está trabajando con colecciones y no ha implementado hashCode() , podrían ocurrir cosas extrañas y extrañas:

HashMap<Cat, String> 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() .

Answer 4

Con respecto a la clase String:

El método equals () compara el "valor" dentro de las instancias de String (en el montón) independientemente de si las dos referencias de objeto se refieren a la misma instancia de String o no. Si alguna de las dos referencias de objeto de tipo String se refieren a la misma instancia de String, ¡excelente! Si las dos referencias de objeto se refieren a dos instancias de String diferentes ... no hay 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 String . Si el valor de ambas referencias de objeto "se refiere" a la misma instancia de String, entonces el resultado de la expresión booleana sería "verdadero" .. duh. Si, por otro lado, el valor de ambas referencias de objeto "se refiere a" diferentes instancias de String (aunque ambas instancias de String tienen "valores" idénticos, es decir, el contenido de las matrices de caracteres de cada instancia de String es el mismo) El resultado de la expresión booleana sería "falso".

Como con cualquier explicación, déjalo entrar.

Espero que esto aclare las cosas un poco.

Answer 5

Cuando evalúa el código, es muy claro que (==) se compara de acuerdo con la dirección de la memoria, mientras que es igual a (Objeto o) compara hashCode () de las instancias. Por eso se dice que no rompa el contrato entre equals () y hashCode () si no se enfrenta a 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
    */

Answer 6

Dado que Java no admite la sobrecarga de operadores, == se comporta de manera idéntica para cada objeto, pero igual que () es un método, que se puede anular en Java y la lógica para comparar objetos se puede cambiar según las reglas comerciales.

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

La comparación de cadenas es un escenario común en el que se utilizan los métodos == y equals. Como la anulación de la clase java.lang.String es igual al método, Devuelve true si dos objetos String contienen el mismo contenido, pero == solo devolverá true si dos referencias apuntan al mismo objeto.

Este es un ejemplo de comparación de dos cadenas en Java para la igualdad utilizando 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);

}
}

Answer 7

El operador ==:

El == es un operador relacional en Java que se utiliza para comparar dos operandos. Se utiliza para determinar si los dos operandos son iguales o no. Usando el operador ==, puedes 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 usa con objetos, el operador == compara las dos referencias de objetos 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

Answer 8

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 por defecto es el método equals(Object o) de la clase padre más cercana que haya anulado este método.
• Si ninguna clase principal ha proporcionado una anulación, entonces el método predeterminado de la clase principal final, Objeto, se queda con el método Object#equals(Object o) . Según la API de objetos, esto es igual 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, estarás probando la igualdad de objetos y no la igualdad funcional .
• Siempre recuerde anular el hashCode si anula los equals para no "romper el contrato". Según la API, el resultado devuelto del 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.

Answer 9

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

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

Podemos usar los operadores == para la comparación de referencias (comparación de direcciones) y el método .equals () para la comparación de contenido. En palabras simples, == comprueba 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 igual, entonces, de manera predeterminada, utiliza el método igual (Objeto o) de la clase primaria más cercana que ha anulado este método. Mira esto para más detalles.

Answer 10

En resumen, la respuesta es "Sí". En Java, el operador == compara los dos objetos para ver si apuntan a la misma ubicación de memoria. Mientras que el método .equals() realidad compara los dos objetos para ver si tienen el mismo valor de objeto.

Answer 11

Hay algunas pequeñas diferencias dependiendo de si se trata de "primitivos" o "Tipos de objetos"; lo mismo se puede decir si se trata de miembros "estáticos" o "no estáticos"; También puedes mezclar todo lo anterior ...

Aquí hay un ejemplo (puedes 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:

• ==: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
• .equals (...): http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)

Answer 12

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

La mejor manera de responder esta pregunta será haciéndote algunas preguntas. así que vamos a empezar:

¿Cuál es la salida para el siguiente programa:

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 aun así te preguntaré, ¿por qué crees que eso es correcto?

Ok, vamos a tratar de responder a esto:

¿Cuál es la salida para el siguiente programa:

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

Ahora si tu dices

false
true

Diré que estás equivocado, pero ¿por qué está mal ahora ? La salida correcta para este programa es

true
false

Por favor compare el programa anterior y trate de pensar en ello.

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

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 intentar pensar en el resultado 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() todavía no es el mismo para todos.

Ahora intenta descomentar esta línea // mango2 = "mang"; y ejecútalo nuevamente esta vez, verás que los tres identityHashCode() son diferentes. Hmm, eso es una pista ú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 cuerda "mango" que fue señalada (referenciada) por la variable mango algo como esto

mango ----> "mango"

Ahora en la siguiente línea cuando dije:

mango2 = "mango";

En realidad, reutilizó la misma cuerda "mango" que se ve así.

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

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

mango3 = new String("mango")

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

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

mango3 ------> "mango"

Y es por eso que cuando puse los valores para mango == mango2 , se puso true . y cuando puse el valor para mango3 == mango2 , mango3 == mango2 false (incluso cuando los valores eran los mismos).

y cuando descomentaste la línea // mango2 = "mang"; En realidad creó una cadena "mang" que dio vuelta a nuestro gráfico de esta manera:

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

Es por esto que identityHashCode no es el 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 hágamelo saber si estoy equivocado.

Answer 13

La principal diferencia entre == y es igual a () es

1) == se utiliza 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 utiliza 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

Answer 14

Puede valer la pena agregar que para los objetos de envoltorio para tipos primitivos, es decir, Int, Long, Double - == 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, al colocar los dos Longs anteriores en dos ArrayLists separadas, equals los ve como iguales, pero == no lo hace.

ArrayList<Long> c = new ArrayList<>();
ArrayList<Long> 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.");

Answer 15

Solo recuerde que .equals(...) debe 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 Objeto hace lo mismo que la operación de comparación: Object#equals .

La única vez que realmente desea utilizar el operador de comparación para objetos es cuando 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 así:

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

Y no tendrás ningún problema en absoluto.

Answer 16

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

Y == realidad mira valores para tipos primitivos, para objetos verifica la referencia.

Answer 17

Tanto == como .equals () se refieren al mismo objeto si no reemplaza .equals ().

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

Answer 18

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

El método equals compara los objetos.

El operador binario == compara las direcciones de memoria.

Answer 19

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

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

Answer 20

== se puede usar en muchos tipos de objetos, pero puede usar Object.equals para cualquier tipo, especialmente cadenas y marcadores de mapas de Google.

Answer 21

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

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

Answer 22

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

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

P.ej:

assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;

Compensación de complejidad: lo siguiente puede sorprenderlo:

assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;

Le aconsejo que se mantenga alejado de dicha .equals , y siempre use .equals para objetos, y == para primitivos:

assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);

Answer 23

 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

Answer 24

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