Java - Come verificare se una divisione è un intero o un float?

Question

Non riesco a pensare ad un titolo migliore. Bene il problema è: Ho il "int i", può essere qualsiasi valore. il mio obiettivo è trasformare "int i" nel numero più vicino divisibile per .

Ad esempio, ho ottenuto i = 33. Quindi verrò convertito in (16x2). Ma se ottengo i = 50, verrà convertito in (16x3).

Ho provato molte cose, ad esempio:

for (int x = i; x < 999; x++){ 
if ((i - x)/16 *is an integer*){ 
i = i - x; 
} 

ma non so come verificare se un numero intero. Quindi forse il mio codice precedente funziona, ma ho solo bisogno di trovare un modo per verificare se è un intero o un float. Quindi ... ogni aiuto è apprezzato.

Answer 1

Poiché tutti interi che sono divisibili per 16 avranno la loro ultimi 4 bit tutto pronto per 0. È possibile realizzare ciò che si vuole, senza un loop o anche un'istruzione if:

i &= 0xfffffff0; // Sets i to the greatest multiple of 16 less than i, or 0 for i < 16 

ad esempio:

int i = 50; 
i &= 0xfffffff0; // i == 48 

i = 39; 
i &= 0xfffffff0; // i == 32 

i = 16; 
i &= 0xfffffff0; // i == 16 

Answer 2

(i - x)/16 è numero intero quando restante (i - x)/16 è 0. Utilizzare% (modulo) operatore come:

if((i - x)%16 == 0) { 
    // (i-x)/16 is integer 
} 

Answer 3

Utilizzare l'operatore mod. Mod ti dà il resto di un'operazione di divisione.

public boolean isEvenlyDivisable(int a, int b) { 
    return a % b == 0; 
} 

Answer 4

per scoprire se un numero si divide equamente un'altra, controllare le altre risposte, modulo (%) è il modo per farlo.

Per fare ciò che si vuole fare in precedenza, non occorre un ciclo:

public int nearestDivider(final int input) 
{ 
    final int multiple = input/16; // this will divide by 16 and it's integer math, so it loses the decimal 
    return multiple * 16; 
} 

che restituirà 48 se si dà 50 come il vostro esempio.

Se si vuole veramente più vicino allora si dovrà fare un po 'la divisione in virgola mobile

public int nearestDivider(final int input) 
{ 
    final int multiple = Math.round((float) input/16); 
    return multiple * 16; 
} 

Ora 46 restituisce 48, 149 rendimenti 144 ecc

Answer 5

Ci sono una serie di problemi che colpiscono con il codice originale:

1. Se si esegue l'arrotondamento al multiplo più vicino a 16, ne consegue che il valore più alto che si può avere per il substrato 15. Il limite superiore del loop deve essere al massimo 15.
2. Come altri hanno notato, è possibile utilizzare l'operatore modulo (%) per determinare il valore esatto da sottrarre da un valore dato per arrotondarlo alla multiplo più vicino di 16. Ciò elimina completamente la necessità di un ciclo.
3. Ma poiché 16 è una potenza di 2 e poiché gli interi sono rappresentati come un numero binario di 32 cifre (cioè 32 bit), è possibile calcolare il valore più direttamente utilizzando una maschera di bit per azzerare qualsiasi cifra inferiore a 16 nel numero. In Java è possibile utilizzare l'operatore binario & a tale scopo in questo modo: i & 0xfffffff0. Questo azzererà le ultime 4 cifre (quelle che rappresentano: 8-4-2-1), che arrotonda efficacemente il numero fino al valore più vicino divisibile per 16.
4. Se è necessario eseguire la divisione del numero intero e ignorare qualsiasi resto è possibile semplicemente spostare (>>) di 4 bit per farlo invece.

Answer 6

Se è necessario il più vicino multiplo di 16, allora si hanno due casi per trattare con multipli dispari di 8. 1. 8 diventa 16, 24 diventa 32 2. 8 diventa 0, 24 diventa 16

Per la prima:

int j = ((i+8)/16)*16; 

Nel secondo caso:

int j = ((i+7)/16)*16; 

Se si desidera sempre arrotondare verso il basso (ad es. 17 diventa 16, e 15 diventa 0):

int j = (i/16)*16; 

Se si voleva arrotondare sempre UP (non quello che dice il tuo esempio), avresti fatto questo, invece:

int j = ((i+15)/16)*16; 

Answer 7

Al fine di verificare se un altro risultato di divisione in un numero intero o frazione è necessario quanto segue:

int n = 9; 
int p = 3; 

if (n % p == 0) { 
    //the division results in an integer. 
} 
else 
{ 
    //the division results in a fraction. 
} 

Si può fare questo come alternativa:

if (n/p == Math.ceil((double) n/(double) p)) { 
    //the division results in an integer. 
} 
else 
{ 
    //the division results in a fraction. 
} 

Uno ha bisogno Math .ceil() e non rotondo o piano, perché una divisione intera è quasi uguale a un piano e la frazione verrà arrotondata e apparirà come "divisione intera".