Come verificare se un doppio è un numero intero

Question

È possibile farlo?

double variable; 
variable = 5; 
/* the below should return true, since 5 is an int. 
if variable were to equal 5.7, then it would return false. */ 
if(variable == int) { 
    //do stuff 
} 

so il codice probabilmente non va qualcosa di simile, ma come fa è andata?

Answer 1

if ((variable == Math.floor(variable)) && !Double.isInfinite(variable)) { 
    // integer type 
} 

Questo controlla se il valore arrotondato del doppio è uguale al doppio.

La variabile può avere un valore int o doppio e ha sempre un valore int, quindi se la variabile è uguale a Math.floor(variable), deve avere un valore int.

Anche questo non funziona se il valore della variabile è infinito o negativo infinito, quindi aggiungendo 'finché la variabile non è inifinita' alla condizione.

Answer 2

public static boolean isInt(double d) 
{ 
    return d == (int) d; 
} 

Answer 3

public static boolean isInteger(double d) { 
    // Note that Double.NaN is not equal to anything, even itself. 
    return (d == Math.floor(d)) && !Double.isInfinite(d); 
} 

Answer 4

Guava: DoubleMath.isMathematicalInteger. (Divulgazione: l'ho scritto.) Oppure, se non stai già importando Guava, x == Math.rint(x) è il modo più veloce per farlo; rint è misurabilmente più veloce di floor o ceil.

Answer 5

Oppure si potrebbe usare l'operatore modulo:

(d % 1) == 0

Answer 6

si potrebbe provare in questo modo: ottenere il valore intero del doppio, sottrarre questo dal valore doppio originale, definire un intervallo di arrotondamento e test se il numero assoluto del nuovo valore doppio (senza la parte intera) è maggiore o minore dell'intervallo definito. se è più piccolo puoi intenderlo è un valore intero. Esempio:

public final double testRange = 0.2; 

public static boolean doubleIsInteger(double d){ 
    int i = (int)d; 
    double abs = Math.abs(d-i); 
    return abs <= testRange; 
} 

Se si assegna a d il valore 33.15 il metodo restituisce true. Per ottenere risultati migliori è possibile assegnare valori più bassi a testRange (come 0.0002) a propria discrezione.

Answer 7

Prova questo modo,

public static boolean isInteger(double number){ 
    return Math.ceil(number) == Math.floor(number); 
} 

ad esempio:

Math.ceil(12.9) = 13; Math.floor(12.9) = 12; 

quindi 12,9 è non intero, tuttavia

Math.ceil(12.0) = 12; Math.floor(12.0) =12; 

quindi 12.0 è intero

Answer 8

Ecco una versione per Integer e Double:

private static boolean isInteger(Double variable) { 
    if ( variable.equals(Math.floor(variable)) && 
      !Double.isInfinite(variable)   && 
      !Double.isNaN(variable)    && 
      variable <= Integer.MAX_VALUE   && 
      variable >= Integer.MIN_VALUE) { 
     return true; 
    } else { 
     return false; 
    } 
} 

Per convertire Double-Integer:

Integer intVariable = variable.intValue(); 

Answer 9

Ecco una soluzione:

float var = Your_Value; 
if ((var - Math.floor(var)) == 0.0f) 
{ 
    // var is an integer, so do stuff 
} 

Answer 10

Simile a SkonJeet di rispondi a bove, ma le prestazioni sono migliori (almeno in java):

Double zero = 0d;  
zero.longValue() == zero.doubleValue() 

Answer 11

Personalmente, preferisco la semplice soluzione di operazione modulo nella risposta accettata. Sfortunatamente, SonarQube non apprezza i test di uguaglianza con punti fluttuanti senza impostare una precisione rotonda. Quindi abbiamo cercato di trovare una soluzione più conforme. Eccolo:

if (new BigDecimal(decimalValue).remainder(new BigDecimal(1)).equals(BigDecimal.ZERO)) { 
    // no decimal places 
} else { 
    // decimal places 
} 

Remainder(BigDecimal) restituisce un BigDecimal il cui valore è (this % divisor). Se questo è uguale a zero, sappiamo che non esiste un punto variabile.

Answer 12

consideri:

Double.isFinite (value) && Double.compare (value, StrictMath.rint (value)) == 0 

Questo attacca al core Java ed evita un confronto di uguaglianza tra i valori in virgola mobile (==) che è consdered male. Il isFinite() è necessario poiché rint() passa ai valori infiniti.