“===“ equivalente en Java

operators

Question

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.

Answer 1

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 .

Answer 2

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

Answer 3

No hay un concepto de verdad y falsedad en Java, por lo que no hay un operador de comparación estricto.

Answer 4

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) 

2. Si la condición 1 anterior no se cumplió, debe verificar su tipo por operador de instancia:

if (secondreference instanctof classoffirstreference)

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

Answer 5

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);
}
...

Answer 6

Si comparamos dos variables en JS podemos usar "==" y "===" ambas. "==" compara valores y "===" compara tipos también.

var x = 10;
var y = ''10'';
console.log(x == y) // true
console.log(x === y) // false

y en Java esto te da un error de compilación porque el tipo no es el mismo.

Answer 7

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.

Answer 8

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

Answer 9

TL; DR

En Java no hay un operador de comparación: === , pero == o equals

Una explicacion mas larga

En lenguajes con poca escritura , como JavaScript, puede usar el operador de comparación estricta ( === ) porque el lenguaje permite la comparación entre variables que tienen diferentes tipos .

Por ejemplo, en JavaScript, no obtendrá un error de compilación si hace esto:

var x = 10;
var y = ''foo'';
console.log(x == y); // false

Y es útil cuando desea comparar variables que pueden contener valores que son "iguales" pero que pueden ser de diferentes tipos.

Por ejemplo

var x = 10;
var y = ''10'';
console.log(x == y) // true
console.log(x === y) // false

En lenguajes fuertemente tipados como Java, no necesita usar un operador de comparación estricto porque el lenguaje ya "maneja" la comparación de tipo.

Por ejemplo:

int x = 10;
String y = "10";
System.out.println("10" == y); // true
System.out.println(x == y); // compile error : Incompatible operand types int and String

Entonces, básicamente, en Java, no hay necesidad de verificar el rigor utilizando === (se informa un error de sintaxis ).

En primer lugar, el compilador se quejará cuando compare valores de diferentes tipos utilizando el operador == y no se puede realizar la conversion .

En el ejemplo anterior del código Java, si desea hacer una comparación entre x e y , podría usar equals :

int x = 10;
String y = "10";
System.out.println(y.equals(x)); // compile warning: Unlikely argument type for equals(): int seems to be unrelated to String

Como nota al margen, observe que el método equals no se puede llamar en tipos primitivos.

Algunas lecturas útiles son:

• 15.21. Operadores de Igualdad
• ¿Cuál es la diferencia entre un lenguaje fuertemente tipado y un lenguaje tipificado estáticamente?
• ¿Qué problemas deberían considerarse cuando se reemplaza a equals y hashCode en Java?