¿Cuál es la diferencia entre & # 8220; .equals & # 8221; y & # 8220; == & # 8221 ;? [duplicar]

Question

    

Esta pregunta ya tiene una respuesta aquí:

    

        
•              ¿Cuál es la diferencia entre == y equals () en Java?                                      23 respuestas                          
    

    

Hoy cambié de conferenciante y él me dijo que usaba un código extraño. (Dijo que es mejor usar .equals y cuando le pregunté por qué, respondió "porque es así")

Entonces, aquí hay un ejemplo:

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

En lugar de 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 manera (usando .equals )?

Encontré esto en un búsqueda rápida pero realmente no puedo entender esa respuesta:

Answer 1

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

Sin embargo, el método igual a puede anularse, 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í x y y son referencias a la misma cadena, porque y es una constante de tiempo de compilación igual a " hola " .

Answer 2

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

Answer 3

Si usted y yo entramos en el banco, cada uno abre una cuenta nueva y cada uno deposita $ 100, entonces ...

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

(Suponiendo definiciones apropiadas de la clase Account , por supuesto. ;-)

Answer 4

== 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, por primitivo, comprueba si tienen el mismo valor. Por otro lado, el método igual comprueba si los dos objetos que se comparan tienen un valor igual (dependiendo de por supuesto, el método igual se ha implementado para los objetos. El método igual no se puede aplicar a las primitivas (lo que significa que si a es un primitivo a.equals (someobject) no está permitido, sin embargo someobject.equals (a) está permitido).

Answer 5

El operador

== compara dos referencias de objeto para verificar si se refieren a la misma instancia. Esto también devolverá verdadero 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 para 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. Volverá verdadero si la cadena coincide, de lo contrario devuelve falso.

Answer 6

En Java, cuando el operador “==” se utiliza 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");

A pesar de que las cadenas tienen los mismos caracteres exactos ("xyz"), el código anterior generará:  obj1 == obj2 es FALSO

La clase

Java String en realidad anula la implementación predeterminada equals () en la clase Object, y anula el método para que verifique solo 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, siempre que la secuencia real de caracteres sea igual, ambos objetos se considerarán 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 generará lo siguiente:

obj1 == obj2 es VERDADERO

Answer 7

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 ...

Answer 8

(1) == puede aplicarse tanto para primitivas como para tipos de objeto, pero el método equals () puede aplicarse solo para tipos de objeto.

(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 de cadena, clases de envoltura, clases de colección).

(3) == da un error de tipos incomparable cuando intenta solicitar tipos heterogéneos, donde el método as igual devuelve falso.

Answer 9

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 programa 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 se refiere a la instancia de String creada por & # 8220; Hello & # 8221; . El objeto al que se refiere s2 se crea con s1 como inicializador. Por lo tanto, el contenido de los dos objetos String es idéntico, pero son objetos distintos. Esto significa que s1 y s2 no se refieren a los mismos objetos y por lo tanto, no son == , como se muestra aquí por la salida del ejemplo anterior:

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

Answer 10

Digamos que " == " El operador devuelve verdadero si ambos operandos pertenecen al mismo objeto, pero cuando devuelve verdadero ya que no podemos asignar múltiples valores a un solo objeto

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 es así, ¿por qué esto es == compara la funcionalidad ...

Answer 11

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 operaciones numéricas & amp; Método equals () para operaciones relacionadas con cadenas. Entonces, para la comparación de objetos, el método equals () sería la elección correcta.