Come verificare se un doppio è un numero intero

È 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 che il codice probabilmente non va qualcosa di simile, ma come si fa a finire?

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

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

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

Anche questo non funziona se il valore della variabile è infinito o infinito negativo, quindi aggiungendo "fintanto che la variabile non è definita" alla condizione.

Oppure potresti usare l'operatore modulo:

(d % 1) == 0

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 flooro ceil.

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

Prova in questo modo,

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

per 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

Ecco una versione per Integere 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 Doublein Integer:

Integer intVariable = variable.intValue();

Tener conto di:

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

Questo si attacca al core Java ed evita un confronto di uguaglianza tra valori in virgola mobile ( ==) che viene considerato male. Il isFinite()occorre come rint()sarà pass-through valori sfioro.

Il modo migliore è con l'operatore modulo

if(val % 1 == 0)

Ecco una buona soluzione:

if (variable == (int)variable) {
    //logic
}

Simile alla risposta di SkonJeet sopra, ma le prestazioni sono migliori (almeno in Java):

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

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

si potrebbe provare in questo modo: ottenere il valore intero del doppio, sottrarlo dal doppio valore originale, definire un intervallo di arrotondamento e verificare se il numero assoluto del nuovo valore doppio (senza la parte intera) è maggiore o minore del valore 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.

Personalmente, preferisco la semplice soluzione operativa modulo nella risposta accettata. Sfortunatamente, a SonarQube non piacciono i test di uguaglianza con punti mobili senza impostare una precisione circolare. Quindi abbiamo cercato di trovare una soluzione più conforme. Ecco qui:

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

Remainder(BigDecimal)restituisce un BigDecimalvalore di cui è (this % divisor). Se questo è uguale a zero, sappiamo che non esiste un punto mobile.

La mia soluzione semplice:

private boolean checkIfInt(double 
 value){
 return value - Math.floor(value) == 0;
 }

Ecco una soluzione:

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