java - objetos - para que sirve equals en android studio
¿Cómo comparo dos enteros? (9)
Esta pregunta ya tiene una respuesta aquí:
- ¿Cómo comparar correctamente dos enteros en Java? 8 respuestas
Tengo que comparar dos objetos Integer (no int ). ¿Cuál es la forma canónica de compararlos?
Integer x = ...
Integer y = ...
Puedo pensar en esto:
if (x == y)
El operador == solo compara referencias, por lo que esto solo funcionará para valores enteros más bajos. Pero tal vez el auto-boxeo patea ...?
if (x.equals(y))
Esto parece una operación costosa. ¿Hay algún código hash calculado de esta manera?
if (x.intValue() == y.intValue())
Un poco detallado ...
EDIT: Gracias por tus respuestas. Aunque sé qué hacer ahora, los hechos se distribuyen en todas las respuestas existentes (incluso las eliminadas :)) y realmente no sé, cuál aceptar. Entonces, aceptaré la mejor respuesta, que se refiere a las tres posibilidades de comparación, o al menos las dos primeras.
if (x.equals(y))Esto parece una operación costosa. ¿Hay algún código hash calculado de esta manera?
No es una operación costosa y no se calculan códigos hash. Java no calcula mágicamente los códigos hash, equals(...) es solo una llamada a método, no diferente de cualquier otra llamada a método.
Es probable que la JVM optimice incluso la llamada al método (haciendo referencia a la comparación que tiene lugar dentro del método), por lo que esta llamada no es mucho más costosa que usar == en dos valores int prim.
Nota: No aplique prematuramente micro-optimizaciones; sus suposiciones como "esto debe ser lento" probablemente sean incorrectas o no importen, porque el código no es un cuello de botella de rendimiento.
"igual" es eso. Para estar seguro, debes probar la nulidad:
x == y || (x != null && x.equals(y))
las pruebas x == y para null == null, que en mi humilde opinión debería ser cierto.
El JIT delineará el código si se lo llama con la frecuencia suficiente, por lo que las consideraciones de rendimiento no deberían importar.
Por supuesto, evitar "Integer" a favor de "int" simple es la mejor manera, si puedes.
[Adicional]
Además, la verificación nula es necesaria para garantizar que la prueba de igualdad sea simétrica, x.equals (y) debería ser igual a y.equals (x), pero no lo es si uno de ellos es nulo.
Acabo de encontrar esto en mi código y me tomó un tiempo resolverlo. Estaba haciendo una intersección de dos listas ordenadas y solo obtenía pequeños números en mi salida. Podría hacer que funcione usando (x - y == 0) lugar de (x == y) durante la comparación.
Compare el número entero e imprima su valor en valor ascendente o descendente. Todo lo que tiene que hacer es implementar la interfaz del Comparador y anular su método de comparación y comparar su valor de la siguiente manera:
@Override
public int compare(Integer o1, Integer o2) {
if (ascending) {
return o1.intValue() - o2.intValue();
} else {
return o2.intValue() - o1.intValue();
}
}
Esto es lo que hace el método igual:
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
Como puede ver, no hay cálculo de código hash, pero hay algunas otras operaciones que tienen lugar allí. Aunque x.intValue() == y.intValue() puede ser un poco más rápido, x.intValue() == y.intValue() territorio de la micro-optimización. Además, el compilador podría optimizar la llamada equals() todos modos, aunque no lo sé con certeza.
En general, usaría la primitiva int , pero si tuviera que usar Integer , me quedaría con equals() .
La clase Integer implementa Comparable<Integer> , así que podrías intentar
x.compareTo(y) == 0
Además, si en lugar de igualdad, está buscando comparar estos enteros, entonces,
x.compareTo(y) < 0 le dirá si x es menor que y.
x.compareTo(y) > 0 le dirá si x es mayor que y.
Por supuesto, sería sabio, en estos ejemplos, asegurar que x no sea nulo antes de hacer estas llamadas.
Me gustaría ir con x.equals (y) porque es una forma consistente de verificar la igualdad para todas las clases.
En lo que respecta al rendimiento, equals es en realidad más caro porque termina llamando a intValue ().
EDIT: debe evitar el autoboxing en la mayoría de los casos. Puede ser realmente confuso, especialmente el autor no sabe lo que estaba haciendo. Puedes probar este código y te sorprenderá el resultado;
Integer a = 128;
Integer b = 128;
System.out.println(a==b);
Nota secundaria: desde Java 1.7, la clase Entero tiene un método de compare(Integer, Integer) estática compare(Integer, Integer) , por lo que puede simplemente llamar a Integer.compare(x, y) y terminar con eso (preguntas sobre optimización a un lado).
Por supuesto, ese código es incompatible con versiones de Java anteriores a 1.7, por lo que recomendaría usar x.compareTo(y) lugar, que es compatible con 1.2.
Usa el método equals . ¿Por qué estás tan preocupado de que sea caro?