java - enteros - integer compareto()

compareTo con primitivos-> Integer/int

Question

¿Es mejor escribir

int primitive1 = 3, primitive2 = 4;
Integer a = new Integer(primitive1);
Integer b = new Integer(primitive2);
int compare = a.compareTo(b);

o

int primitive1 = 3, primitive2 = 4;
int compare = (primitive1 > primitive2) ? 1 : 0;
if(compare == 0){
compare = (primitive1 == primitive2) ? 0 : -1;
}

Creo que el segundo es mejor, debería ser más rápido y tener más memoria optimizada. ¿Pero no son iguales?

Answer 1

¿Puedo proponer un tercero

((Integer) a).compareTo(b)

Answer 2

Ellos ya están enteros. ¿Por qué no solo usar la resta?

compare = a - b;

Tenga en cuenta que Integer.compareTo () no necesariamente devuelve solo -1, 0 o 1 tampoco.

Answer 3

Envolver la primitiva int en un objeto entero le costará algo de memoria, pero la diferencia solo será significativa en casos muy raros (demanda de memoria) (matriz con más de 1000 elementos). No recomendaré el uso de un nuevo constructor Integer (int a) de esta manera. Esto será suficiente:

Integer a = 3;

Acerca de la comparación hay Math.signum (doble d).

compare= (int) Math.signum(a-b);

Answer 4

Para el rendimiento, generalmente es mejor hacer que el código sea lo más simple y claro posible, y esto a menudo tendrá un buen rendimiento (ya que el JIT optimizará mejor este código). En su caso, los ejemplos más simples también son los más rápidos.

Yo haría cualquiera

int cmp = a > b ? +1 : a < b ? -1 : 0;

o una versión más larga

int cmp;
if (a > b)
cmp = +1;
else if (a < b)
cmp = -1;
else
cmp = 0;

o

int cmp = Integer.compare(a, b); // in Java 7
int cmp = Double.compare(a, b); // before Java 7

Es mejor no crear un objeto si no es necesario.

En cuanto a rendimiento, el primero es el mejor.

Si está seguro de que no recibirá un desbordamiento, puede usar

int cmp = a - b; // if you know there wont be an overflow.

no serás más rápido que esto.

Answer 5

Para pre 1.7 diría que un equivalente a Integer.compare (x, y) es:

Integer.valueOf(x).compareTo(y);

Answer 6

Puedes hacerlo a través de la manipulación de bits, algo como esto:

(~a - ~b) >>> 31 | -((a - b) >>> 31)

public static void main(String[] args)
{
int a = 107;
int b = 106;
check(a, b);
a = 106;
b = 106;
check(a, b);
a = 106;
b = 107;
check(a, b);
}
public static void check(int a, int b)
{
System.out.println((~a - ~b) >>> 31 | -((a - b) >>> 31));
}

SALIDA:

1
0
-1

Answer 7

Si está utilizando Java 8, puede crear Comparador por este método:

Comparator.comparingInt(i -> i);

si desea comparar con orden inverso:

Comparator.comparingInt(i -> -i);

Answer 8

Si necesita solo un valor lógico (como casi siempre lo es), el siguiente trazo le ayudará a:

boolean ifIntsEqual = !((Math.max(a,b) - Math.min(a, b)) > 0);

Y funciona incluso en Java 1.5+, tal vez incluso en 1.1 (no tengo uno). Díganos si puede probarlo en 1.5-.

Este también lo hará:

boolean ifIntsEqual = !((Math.abs(a-b)) > 0);

Answer 9

Use Integer.compare(int, int) . Y no intente micro optimizar su código a menos que pueda probar que tiene un problema de rendimiento.