¿Cuál es la diferencia entre == y 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

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 de igualdad, entonces el equals(Object o)método predeterminado es la clase principal más cercana que ha anulado este método.
• Si ninguna clase principal ha proporcionado una anulación, el valor predeterminado es el método de la última clase principal, Object, y así queda el Object#equals(Object o)método. Según la API de objetos, 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 no la igualdad funcional .
• Recuerde siempre anular hashCodesi anula equalspara no "romper el contrato". Según la API, el resultado devuelto por el hashCode()método para dos objetos debe ser el mismo si sus equalsmétodos 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 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 dos referencias de objetos de tipo String se refieren a la misma instancia de String, ¡genial! 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 refieren" a la misma instancia de String, 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" instancias de String diferentes (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, deja que se hunda.

Espero que esto aclare las cosas un poco.

Hay algunas pequeñas diferencias dependiendo de si estás hablando de "primitivas" 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 para "==" (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)

La diferencia entre == e igual me confundió durante algún tiempo hasta que decidí echarle un vistazo más de cerca. Muchos de ellos dicen que para comparar cadenas debe usar equalsy no ==. Espero que en esta respuesta pueda decir la diferencia.

La mejor manera de responder a esta pregunta será haciéndose algunas preguntas. así que empecemos:

¿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 aún te preguntaré, ¿por qué crees que eso es correcto?

Ok, intentemos responder a esta:

¿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 dices,

false
true

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

true
false

Compare el programa anterior y trate de pensarlo.

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

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

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

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

A pesar de que 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útala de nuevo esta vez, verás que las tres identityHashCode()son diferentes. Hmm eso es una pista útil

sabemos que si hashcode(x)=Ny 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 señalada (referenciada) por la variable mangoalgo como esto

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 (cadena) completamente nueva para "mango". que se parece a esto,

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

mango3 ------> "mango"

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

y cuando descomentaste la línea // mango2 = "mang"; , en realidad creó una cadena "mang" que convirtió nuestro gráfico de esta manera:

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

Es por eso 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 pasa igual (). Por favor, siéntase libre de comentar y avíseme 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)

Salud :-)

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

El método igual compara los objetos.

El ==operador binario compara las direcciones de memoria.

Ambos == y .equals () se refieren al mismo objeto si no anula .equals ().

Es tu deseo lo que quieres hacer una vez que anulas .equals (). Puede comparar el estado del objeto que invoca con el estado del objeto pasado o simplemente puede llamar a super.equals ()

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

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

 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

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

La única vez que realmente desea utilizar el operador de comparación para objetos es cuando compara 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 Aa la vez, y lo mismo para By C. Esto significa que puedes escribir un método como este:

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

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

Cuando evalúa el código, queda muy claro que (==) se compara de acuerdo con la dirección de memoria, mientras que igual (Object o) compara el 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 tarde.

    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
    */

Aquí hay una regla general para la diferencia entre relational operator ==y the method .equals().

object1 == object2compara si los objetos a los que hace referencia object1 y object2 hacen referencia a la misma ubicación de memoria en Heap .

object1.equals(object2)compara los valores de object1 y object2 independientemente de dónde se encuentren en la memoria .

Esto se puede demostrar bien usando String

escenario 1

 public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = new String("Hello");
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

 }



The result is
      is str1 == str2 ? false
      is str1.equals(str2) ? true 

Escenario 2

public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = "Hello";
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

}

The result is 
  is str1 == str2 ? true
  is str1.equals(str2) ? true

Esta comparación de cadenas podría usarse como base para comparar otros tipos de objetos.

Por ejemplo, si tengo una clase de Persona , necesito definir la base de criterios en la que compararé a dos personas . Digamos que esta clase de persona tiene variables de instancia de altura y peso.

Por lo tanto, crear objetos personales person1 and person2y comparar estos dos utilizando el método.equals() Necesito anular el método de igualdad de la clase de persona para definir en función de qué variables de instancia (altura o peso) será la comparación.

Sin embargo, el == operator will still return results based on the memory location of the two objects(person1 and person2).

Para facilitar la generalización de esta comparación de objetos personales, he creado la siguiente clase de prueba. Experimentar con estos conceptos revelará toneladas de hechos .

package com.tadtab.CS5044;

public class Person {

private double height;
private double weight;

public double getHeight() {
    return height;
}

public void setHeight(double height) {
    this.height = height;
}

public double getWeight() {
    return weight;
}

public void setWeight(double weight) {
    this.weight = weight;
}


@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    long temp;
    temp = Double.doubleToLongBits(height);
    result = prime * result + (int) (temp ^ (temp >>> 32));
    return result;
}

@Override
/**
 * This method uses the height as a means of comparing person objects.
 * NOTE: weight is not part of the comparison criteria
 */
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 (Double.doubleToLongBits(height) != Double.doubleToLongBits(other.height))
        return false;
    return true;
}

public static void main(String[] args) {

    Person person1 = new Person();
    person1.setHeight(5.50);
    person1.setWeight(140.00);

    Person person2 = new Person();
    person2.setHeight(5.70);
    person2.setWeight(160.00);

    Person person3 = new Person();
    person3 = person2;

    Person person4 = new Person();
    person4.setHeight(5.70);

    Person person5 = new Person();
    person5.setWeight(160.00);

    System.out.println("is person1 == person2 ? " + (person1 == person2)); // false;
    System.out.println("is person2 == person3 ? " + (person2 == person3)); // true 
    //this is because perosn3 and person to refer to the one person object in memory. They are aliases;
    System.out.println("is person2.equals(person3) ? " + (person2.equals(person3))); // true;

    System.out.println("is person2.equals(person4) ? " + (person2.equals(person4))); // true;

    // even if the person2 and person5 have the same weight, they are not equal.
    // it is because their height is different
    System.out.println("is person2.equals(person4) ? " + (person2.equals(person5))); // false;
}

}

El resultado de esta ejecución de clase es:

is person1 == person2 ? false
is person2 == person3 ? true
is person2.equals(person3) ? true
is person2.equals(person4) ? true
is person2.equals(person4) ? false

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

Y, de ==hecho, analiza los valores para los tipos primitivos, para los objetos verifica la referencia.

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

método equals ()

depende de la implementación si se reemplaza el método igual al que 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 es igual que return false y == también. pero si anulamos 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, verificará que devolverá verdadero y falso para el mismo caso solo que anulamos

método igual

compara el objeto en la base del contenido (id) del objeto

pero ==

Todavía comparar referencias de objeto.

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

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

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 contenedor 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");
}

Por el contrario, al poner los dos Longs anteriores en dos ArrayLists separadas, igual los ve como iguales, pero == no.

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

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

Esto puede brindarle 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 microoptimización, y que siempre use .equalspara objetos y ==primitivas:

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

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

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 .equals()método en realidad compara los dos objetos para ver si tienen el mismo valor de objeto.

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

equals()Es un método heredado de la Objectclase. Este método compara por defecto 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 se ha anulado equals().

Implemente hashCode()cuando el establecimiento de la igualdad sea parte del Contrato de objetos Java. Si está trabajando con colecciones y no ha implementado hashCode(), Strange Bad Things podría suceder:

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

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

Dado que Java no admite la sobrecarga del operador, == se comporta de manera idéntica para cada objeto, pero el método equals (), 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 equals 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 de uso del método tanto == como igual. Dado que la clase java.lang.String reemplaza el método igual, devuelve verdadero si dos objetos String contienen el mismo contenido, pero == solo devolverá verdadero 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 aclarará 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);

}
}