¿Cuál es la diferencia entre ".equals" y "=="?

Question

Cambié los profesores hoy y él declaró que usaba un código extraño para mí. (Dijo que es mejor utilizar .equals y cuando le pregunté por qué, él respondió "porque lo es!")

Así que aquí está un ejemplo:

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

En lugar de lo que estoy acostumbrado a:

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 camino (usando .equals)?

Found this en una búsqueda rápida, pero no puedo dar sentido a esa respuesta:

Answer 1

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

Sin embargo, el método equals se puede anular, 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 ser consciente de que cualquiera de los dos iguales constantes de cadena (principalmente cadenas literales, sino también combinaciones de las constantes de cadena a través de la concatenación) va a terminar haciendo referencia 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 "hello".

Answer 2

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

Answer 3

Si usted y yo cada uno entra en el banco, cada uno abre una cuenta nueva marca, y cada depósito de $ 100, entonces ...

1. myAccount.equals(yourAccount) es true 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 de objeto

== comprueba si dos objetos tienen la misma dirección en la memoria y para la primitiva comprueba si tienen el mismo valor. El método de igualdad, por otra parte, comprueba si los dos objetos que se están comparando tienen un valor igual (dependiendo de cómo, por supuesto, se ha implementado el método equals para los objetos).El método igual no se puede aplicar en primitivas (lo que significa que si a es una primitiva a.equals (someobject) no está permitido, sin embargo se permite someobject.equals (a)).

Answer 5

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 objetos para ver si se refieren a la misma instancia. El programa siguiente muestra cómo dos objetos String diferentes pueden contener los mismos caracteres, pero las referencias a estos objetos no se compara como igual:

// 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 String creado por “Hello”. El objeto al que se hace referencia en 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 son, por lo tanto, no ==, como se muestra aquí por la salida del ejemplo precedente:

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

Answer 6

En Java, cuando el “== El operador "" se usa para comparar 2 objetos, comprueba 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 realidad de salida: obj1 == obj2 es FALSO

clase

String de Java en realidad anula el valor predeterminado equals() implementación en la clase Object - y anula el método para que solo compruebe 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, entonces, siempre que la secuencia real de caracteres sea igual, ambos objetos se consideran 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 es la salida los siguientes:

obj1 == obj2 es TRUE

Answer 7

permite decir que "==" devuelve true si ambos operandos ambos pertenecen al mismo objeto, pero cuando se va return true ya que no podemos asignar un único objeto de múltiples valores

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 su no sucede entonces por qué esto es == compara funcionalidad ....

Answer 8

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 u puede campare los dos '==' y'.equals

aquí .equals se utiliza para comparar los objetos de referencia y '==' se utiliza para comparar el estado de objetos ..

Answer 9

(1) == se puede aplicar tanto para primitivos como para tipos de objetos, pero el método equals() solo se puede aplicar para tipos de objetos.

(2) == no puede anularse para la comparación de contenido, pero el método equals se puede anular para la comparación de contenido (por ejemplo, clase String, clases contenedoras, clases de colección).

(3) == da error de tipo incomparable cuando intentas aplicar para tipos heterogéneos, donde el método igual devuelve falso.

Answer 10

== operador compara dos referencias de objeto para comprobar si se refieren a la misma instancia. Esto también, devolverá verdadero en exitoso ejemplo match.for

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

ejemplo anterior == es una comparación de referencia es decir, ambos objetos apuntan a la misma posición de memoria

cadena es igual a() es evalúa a 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 
    }} 

anterior ejemplo Se compara el contenido de las cadenas. Devolverá verdadero si la cadena coincide, de lo contrario devuelve falso.

Answer 11

Aquí es una simple interpretación acerca de su problema:

== (igual a) que se utiliza para evaluar la expresión aritmética

donde como

iguales() método utilizado para comparar la cadena

Therefo es mejor utilizar == para operaciones numéricas & 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.