ejemplos - int equals c#

Diferencia entre igual/igual y== operador?

Question

¿Cuál es la diferencia entre a == b y a.Equals(b) ?

Answer 1

== es un operador fundamental en el lenguaje. El operador == prueba para ver si dos variables de referencia del objeto se refieren a la misma instancia exacta de un objeto.

equals () es un método de instancia que está definido fundamentalmente por la clase java.lang.Object. El método, .equals () prueba para ver si los dos objetos que se comparan entre sí son equivalentes, pero no es necesario que sean exactamente la misma instancia del mismo objeto.

El operador == siempre le da el mismo resultado, pero el método equals () le da salida de acuerdo con su implementación (lógica implementada). Reemplazo correcto de iguales: Consideraciones ''siempre que anule el método equals ().

1. Reflexivo: para cualquier referencia no nula x, x.equals (x) debería devolver verdadero.

2. Simétrico: para cualquier referencia no nulo x e y, si x.equals (y) es verdadero, entonces y.equals (x) debe devolver verdadero.

3. Transitivo: para cualquier referencia no nula x, y y z, si x.equals (y) es verdadero, y.equals (z) es verdadero, entonces x.equals (z) debe devolver verdadero.

4. Constante: para cualquier referencia no nula xey, las múltiples invocaciones de x.equals (y) devuelven true o consistentemente devuelven false, sin cambiar la información proporcionada para las comparaciones de iguales.

5. Para cualquier referencia no nula x, x.equals (null) debe devolver falso. NOTA: Si o1.equals (o2) es verdadero, entonces o1.hashcode () == o2.hashcode (), pero el reverso puede o no ser cierto.

Ejemplos:

Entero i = nuevo Entero (10); Entero j = i;

en el código anterior. i == j es verdadero porque tanto i como j se refieren al mismo objeto.

Entero i = nuevo Entero (10); Entero j = nuevo Entero (10);

En el código anterior, i == j es FALSO porque, aunque ambos tienen el valor 10, son dos objetos diferentes. Pero i.equals (j) volverá verdadero.

Usando el auto-boxeo

Entero i = 10;
Entero j = 10;
Booleano b = (i == j);
System.out.println (b);

Esto devolverá TRUE porque los enteros entre los rangos -127 a 128 se agrupan, por lo que en este caso ambos son los mismos objetos (JVM no creará un nuevo objeto lo recuperará del grupo).

La clase String anula el método equals, así que aquí hay un ejemplo de iguales vs. == String s1 = new String ("abc"); String s2 = new String ("abc");

NOTA: Las cadenas se crean en el conjunto constante de cadenas, por lo que cuando creamos cadenas como s = "abc" comprobará el grupo invocando el método nativo interno (), para su existencia en el grupo existente si no encontró ninguna cadena, entonces creará uno nuevo, pero si invocamos a un nuevo operador, entonces creará un nuevo String independientemente de verificar si el grupo existe.

  public class StringEqualityTest {
    public static void main(String []a){

    String s1=new String("abc");
    String s2=new String("abc");

     System.out.print("s1.equals(s2)  :"+s1.equals(s2)+"  s1==s2   :");
     System.out.println(s1==s2);

     String s3="abc";
     String s4="abc";

     System.out.print("s3.equals(s4)  :"+s1.equals(s2)+"  s3==s4   :");
     System.out.println(s3==s4);

       }

       }

SALIDA: s1.equals (s2): verdadero s1 == s2: falso s3.equals (s4): verdadero s3 == s4: verdadero

Answer 2

== verifica si las referencias apuntan al mismo objeto en la memoria

Ahora,

aunque el método del código de iguales en la clase de objeto no es más que verificar == para las referencias, puede anularse para agregar sus propias verificaciones de igualdad.

En clases como String, el método reemplazado comprueba si los literales de cadena son correctos o no. Entonces, básicamente se puede usar para verificar si el valor es el mismo o no.

Answer 3

==, solo devuelve un valor de código hash de acuerdo con sus direcciones para que las diferentes direcciones, incluso si las cadenas o cualquier dato que sea similar también devuelvan falso ... Esta ayuda completa para las condiciones, devuelve un valor booleano.

Answer 4

Depende de los tipos de b .

En particular, Equals es un método virtual, por lo que su comportamiento no depende de los tipos de tiempo de compilación de a y b.

En Java, == siempre se comparará por referencia, que no es necesariamente lo que quiere, especialmente para cadenas.

En C #, == puede estar sobrecargado, pero no es virtual (es un método static ). Por lo tanto, si a o b se declaran como object , se compararán por referencia, incluso si su tipo real sobrecarga al operator == .

Además, a.Equals(b) lanzará una NullReferenceException ( NullPointerException en Java) si a es null .

Answer 5

El operador == comprueba si dos objetos son exactamente el mismo objeto, que no es el camino a seguir en la mayoría de los casos. El método Equals podrá comparar el objeto internamente

Ejemplo:

class Mycar
{
  string color;
  Mycar(string str)
 {
   color = str;
 }
}   

Mycar a = new Mycar("blue");
Mycar b = new Mycar("blue");
a==b // Returns false
a.Equals(b) // Returns true

Answer 6

Supongamos que tenemos a y b dos objetos diferentes y queremos comparar estas dos referencias de objetos. Luego usamos el operador == y cuando usamos a.equals(b) , se comparan los valores de cadena.

Answer 7

Suponiendo que los tipos de a y b son tipos de referencia:

• En Java, == siempre se comparará para la identidad , es decir, si los dos valores son referencias al mismo objeto. Esto también se llama igualdad de referencia . Java no tiene ninguna sobrecarga de operador definida por el usuario.

• En C # depende. A menos que haya un operador sobrecargado que lo maneje, == se comportará como Java (es decir, comparando para la igualdad de referencia). Sin embargo, si hay una sobrecarga que coincida con los tipos de tiempo de compilación b (por ejemplo, si ambos se declaran como cadenas), se invocará esa sobrecarga. Eso puede comportarse como quiera, pero normalmente implementa igualdad de valores (es decir, a y b pueden referirse a valores diferentes pero iguales y aún así devolvería verdadero).

En ambos idiomas, a.Equals(b) o a.equals(b) llamarán al método virtual Equals / equals declarado por Object , a menos que se haya introducido una sobrecarga más específica por el tipo de tiempo de compilación de a . Esto puede o no anularse en el tipo de tiempo de ejecución del objeto al que se refiere a. Tanto en .NET como en Java, la implementación en Object también verifica la identidad. Tenga en cuenta que esto depende del tipo de tiempo de ejecución en lugar del tipo de tiempo de compilación del que depende la resolución de sobrecarga.

Por supuesto, si a es null entonces obtendrá una NullReferenceException / NullPointerException cuando intente llamar a.equals(b) o a.Equals(b) .

Answer 8

== usa la referencia de un objeto, o si es un entero / flotante, etc., entonces compara el número real. Técnicamente, solo compara lo que está en la ubicación de la memoria. Mientras que .equals utiliza un método dentro de la clase de objeto para comparar objetos, puede anularse para sus clases individuales. Además, como las matrices también se ocupan de las referencias, también es útil no utilizar array1[i] = array2[i] , use arraycopy o clone() . Creo que .equals también se puede usar con matrices

Answer 9

== verifica la referencia del objeto, básicamente compara los códigos hash. Igual usa los contenidos en el objeto. Recuerde, tenemos que anular el método de .equals en consecuencia en nuestra clase.

Answer 10

a == b devuelve verdadero si las referencias contienen el mismo valor, es decir, apuntan al mismo objeto, o ambos son nulos.

El método equals() puede anularse para comparar objetos. Por ejemplo, en Strings , el método devuelve true si las cadenas contienen la misma cadena, incluso si son diferentes objetos de cadena. Puedes hacer cosas similares con tus propios objetos.

o.equals() lanzará una excepción si o es una referencia nula.

Answer 11

String a = "toto".Substring(0, 4);
String b = "toto";
Object aAsObj = a;
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(a == b);
Assert.IsFalse(aAsObj == b);
Assert.IsTrue(aAsObj.Equals(b));

Este pase de prueba en .NET, el truco es que Equals es un método, mientras que == es un método static , por lo que aAsObj == b use

static bool Object.operator==(object a, object b) //Reference comparison

mientras que a == b uso

static bool String.operator==(string a, string b) //String comparison

pero a.Equals(b) o aAsObj.Equals(b) siempre usan:

bool String.Equals(Object obj) //String comparison