Diferencia entre comparar String usando el método == y .equals() en Java

Tanto el método equals() como el operador == se utilizan para comparar dos objetos en Java. == es un operador y equals() es un método. Pero el operador == compara la referencia o la ubicación de la memoria de los objetos en un montón, ya sea que apunten a la misma ubicación o no.
Cada vez que creamos un objeto usando el operador nuevo, creará una nueva ubicación de memoria para ese objeto. Entonces usamos el operador == para verificar que la ubicación de la memoria o la dirección de dos objetos sean iguales o no.

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

1. La principal diferencia entre el método .equals() y el operador == es que uno es un método y el otro es el operador.
2. 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, == 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.
3. Si una clase no anula el método equals , de forma predeterminada, utiliza el método equals(Object o) de la clase principal más cercana que ha anulado este método. Consulte ¿Por qué anular los métodos equals(Object) y hashCode()? en detalle.

// Java program to understand 
// the concept of == operator
  
public class Test {
    public static void main(String[] args)
    {
        String s1 = "HELLO";
        String s2 = "HELLO";
        String s3 =  new String("HELLO");
  
        System.out.println(s1 == s2); // true
        System.out.println(s1 == s3); // false
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // true
    }
}

true
false
true
true

Explicación: Aquí creamos dos objetos, a saber, s1 y s2. 

• Tanto s1 como s2 se refieren a los mismos objetos.
• Cuando usamos el operador == para la comparación de s1 y s2, el resultado es verdadero ya que ambos tienen las mismas direcciones en el conjunto de constantes de string.
• Usando iguales, el resultado es verdadero porque solo está comparando los valores dados en s1 y s2.

                                                                                                           Grupo de strings de Java

                                                                                                              Montón de Java

Entendamos ambos operadores en detalle:

Operador de igualdad (==)

Podemos aplicar operadores de igualdad para cada tipo primitivo, incluido el tipo booleano. También podemos aplicar operadores de igualdad para tipos de objetos. 

// Java program to illustrate 
// == operator for compatible data
// types
  
class Test {
    public static void main(String[] args)
    {
        // integer-type
        System.out.println(10 == 20);
  
        // char-type
        System.out.println('a' == 'b');
  
        // char and double type
        System.out.println('a' == 97.0);
  
        // boolean type
        System.out.println(true == true);
    }
}

false
false
true
true

Si aplicamos == para los tipos de objetos, debería haber compatibilidad entre los tipos de argumentos (ya sea de niño a padre o de padre a hijo o del mismo tipo). De lo contrario, obtendremos un error en tiempo de compilación. 

// Java program to illustrate 
// == operator for incompatible data types
  
class Test {
    public static void main(String[] args)
    {
        Thread t = new Thread();
        Object o = new Object();
        String s = new String("GEEKS");
  
        System.out.println(t == o);
        System.out.println(o == s);
  
       // Uncomment to see error 
       System.out.println(t==s);
    }
}

Producción: 

false
false
// error: incomparable types: Thread and String

Método .equals()

En Java, el método String equals() compara las dos strings dadas en función de los datos/contenido de la string. Si todos los contenidos de ambas strings son iguales, devuelve verdadero. Si todos los caracteres no coinciden, devuelve falso. 

public class Test {
    public static void main(String[] args)
    {
        Thread t1 = new Thread();
        Thread t2 = new Thread();
        Thread t3 = t1;
  
        String s1 = new String("GEEKS");
        String s2 = new String("GEEKS");
  
        System.out.println(t1 == t3);
        System.out.println(t1 == t2);
        System.out.println(s1 == s2);
  
        System.out.println(t1.equals(t2));
        System.out.println(s1.equals(s2));
    }
}

true
false
false
false
true

Explicación: aquí estamos usando el método .equals para comprobar si dos objetos contienen los mismos datos o no. 

• En el ejemplo anterior, creamos 3 objetos Thread y 2 objetos String.
• En la primera comparación, comprobamos si t1 == t3 o no. Como sabemos que tanto t1 como t3 apuntan al mismo objeto . Es por eso que devuelve verdadero.
• En la segunda comparación, usamos el operador “==” para comparar los objetos de string y no el contenido de los objetos. Aquí, ambos objetos son diferentes y, por lo tanto, el resultado de esta comparación es «Falso».
• Cuando estamos comparando 2 objetos de string por el operador .equals(), entonces estamos comprobando si ambos objetos contienen los mismos datos o no.
• Ambos objetos contienen la misma string, es decir, GEEKS. Es por eso que devuelve verdadero.

Este artículo es una contribución de Veturi Lakshmi Prathyusha . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.