implement - string compareto() java




comparePer i primitivi-> Integer/int (6)

È meglio scrivere

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

Penso che il secondo sia migliore, dovrebbe essere più veloce e più ottimizzato per la memoria. Ma non sono uguali?


Il wrapping int primitivo in oggetto intero ti costerà un po 'di memoria, ma la differenza sarà significativa solo in casi molto rari (richiesta di memoria) (array con oltre 1000 elementi). Non raccomanderò di usare il nuovo costruttore Integer (int a) in questo modo. Questo sarà sufficiente:

Integer a = 3; 

A proposito del confronto c'è Math.signum (double d).

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

Per le prestazioni, di solito è meglio rendere il codice il più semplice e chiaro possibile e questo spesso si comporta bene (poiché il JIT ottimizzerà questo codice al meglio). Nel tuo caso, anche gli esempi più semplici sono probabilmente i più veloci.

Lo farei entrambi

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

o una versione più lunga

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

È meglio non creare un oggetto se non è necessario.

Per quanto riguarda le prestazioni, il primo è il migliore.

Se sai per certo che non otterrai un overflow che puoi utilizzare

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

non sarai più veloce di così


Posso proporre un terzo

((Integer) a).compareTo(b)  

Puoi farlo tramite la manipolazione del bit, qualcosa del genere:

(~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));
}

PRODUZIONE:

1
0
-1

Se stai usando java 8, puoi creare Comparator con questo metodo:

Comparator.comparingInt(i -> i);

se desideri confrontare con l'ordine inverso:

Comparator.comparingInt(i -> -i);

Sono già ints. Perché non usare solo la sottrazione?

compare = a - b;

Notare che Integer.compareTo () non restituisce necessariamente solo -1, 0 o 1.







compareto