“===“ equivalente en Java




operators (6)

En Java puedes comparar tipos primitivos como int, double, char, long, float usando '=='. En este caso se comparan los valores. Para la comparación de objetos, esto no es suficiente porque '==' se evalúa solo como 'verdadero' si las identidades de los objetos comparados son iguales - 'identidad' es la dirección de memoria donde se almacena el objeto. Esto se debe al hecho de que todas las clases heredan implícitamente todos los métodos proporcionados por la clase 'Objeto' y donde el método 'equals ()' contiene solo una implementación básica. Debido a esto, cualquier clase cuyos objetos estén involucrados en comparaciones, utilizados en estructuras de datos o fuera de su propio paquete, debe contener una implementación sólida de equals () y hashCode (): método para proporcionar la funcionalidad correcta.

Considere la siguiente implementación:

float[] s1 = {1,2,3};
int[] s2 = {1,2,3};
//compareDatab gives false

También revise la API oficial de Java para obtener más información https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html .

Al comparar dos valores en Java, ¿cómo se prueba si ambos, el tipo y el valor, son equivalentes?

Sé que en JavaScript === se puede usar para lograr esto, así que lo intenté en Java, pero no funcionó.

Sé que esta es una pregunta simple, pero traté de buscarla y no pude averiguar qué era.


Hice una función que rplica la funcionalidad de === de Javascript en Java

public class MyClass {

  private final int val;
  private final String name;

  public MyClass(int val, String name) {
     this.val = val;
     this.name = name;
  }

  public int getVal() { return val; }

  public String getName() { return name; }

  public boolean equals(Object o) {
     if(o == null) return false;
     if(this == o) return true;
     if(!this.getClass().getSimpleName().equals(o.getClass().getSimpleName()) return false;

     MyClass other = (MyClass) o;

     return this.getVal() == other.getVal() && this.getName().equals(other.getName());
  }

  public int hashCode() { ... }

}

Pude pasar valores de cualquier tipo de datos (excepto la matriz) a esta función, así como obtener verdadero solo si el tipo de datos y los valores coinciden, de lo contrario devuelve falso. Los tipos de datos derivados como List y HashMap también funcionan .

La llamada a esta función se ve así:

static boolean compareData(Object v1, Object v2)
{
    if(v1 != null && v2 != null)
        return (v1.getClass() == v2.getClass() && (v1.toString().equals(v2.toString())));
    else
    {
        return (v1 == null ? v2 == null : v1.equals(v2));
    }
}
float s1 = 0.f;
float s2 = 0.1f;

System.out.println(compareData(s1, s2)); //Returns false
float s1 = 0.0f;
float s2 = 0.0f;

System.out.println(compareData(s1, s2)); //Returns true
float s1 = 0.1f;
String s2 = "0.1f";

System.out.println(compareData(s1, s2)); //Returns false 
String s1 = "sdf";
String s2 = null;

System.out.println(compareData(s1, s2)); //Returns false 

y así...

Actualización: también pude comparar matrices , a continuación se muestra el fragmento de código, pero no he probado este código de manera intensiva, pero funcionó en cada caso de prueba que realicé.

String s1 = null;
String s2 = null;

System.out.println(compareData(s1, s2)); //Returns true

Uso del fragmento de código anterior (las siguientes inicializaciones deben realizarse antes del fragmento de código anterior, smh: P):

if(s1 != null && s2 != null)
    if(s1.getClass().isArray() && s2.getClass().isArray())
        compareDatab = s1.getClass().equals(s2.getClass()) && (Arrays.toString(s1).equals(Arrays.toString(s2)));
    else
        compareDatab = compareData(s1, s2);
else
    compareDatab = compareData(s1, s2);
//s1 and s2 can be anything including Arrays and non-Array...
int[] s1 = {1,2,3};
int[] s2 = {1,2,3};
//compareDatab gives true
int[] s1 = {1,2,4};
int[] s2 = {1,2,3};
//compareDatab gives false

Donde compareData () es la misma función que se indicó anteriormente en esta respuesta.

Espero que esto te sea útil. :)


No hay un operador === para la comparación. Cuando desee comparar dos referencias, debe marcar - 1. Si están apuntando al mismo objeto.

if(firstreference==secondreference) 
  1. Si la condición 1 anterior no se cumplió, debe verificar su tipo por operador de instancia:
if (secondreference instanctof classoffirstreference)
  1. Si se cumple la condición 2 anterior, debe verificar las comparaciones de propiedades por igual operador como
firstreference.property1.equals(secondreference.property1)
//do this for all properties.

No puedo ver ningún beneficio de escribir mi propio comparador para esto. especialmente si ya existe una implementación nativa para esto.

java.util.Objects es tu amigo.

Contiene un montón de pequeño ayudante, como

Objects.compare(object1, object2, comparator);
Objects.equals(object1, object2);
Objects.deepEquals(object1, object2);
Objects.hash(object1, object2, object3, ...);

Uso Objects.equals para sobrescribir en iguales y Objects.hash en los métodos hashCode. También realiza verificaciones nulas para usted y, al final, el código se ve muy limpio y legible.

Por ejemplo:

...

@Override
public boolean equals(Object o) {
    if (this == o) {
        return true;
    }
    if (!(o instanceof Customer)) {
        return false;
    }
    Customer that = (Customer) o;
    return Objects.equals(firstName, that.firstName)
            && Objects.equals(lastName, that.lastName)
            && Objects.equals(street, that.street)
            && Objects.equals(houseNumber, that.houseNumber)
            && Objects.equals(postalCode, that.postalCode)
            && Objects.equals(city, that.city)
            && Objects.equals(emailAddress, that.emailAddress);
}

@Override
public int hashCode() {
    return Objects.hash(firstName,
            lastName,
            street,
            houseNumber,
            postalCode,
            city,
            emailAddress);
}

...

Si dos variables no son del mismo tipo, no puede compararlas, por lo que en este caso == será suficiente. Si no son convertibles, lanzará un error de compilación.


=== es útil en lenguajes de tipo débil, como Javascript, porque verifica que los objetos que se comparan son del mismo tipo y evita las conversiones implícitas.

=== tiene ningún uso en un lenguaje fuertemente tipado como Java porque no puedes comparar variables de diferentes tipos sin escribir un método específico para hacer esto.





operators