Comment tester si un double est un entier

Est-il possible de faire cela?

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
}

Je sais que le code ne va probablement pas quelque chose comme ça, mais comment n'aller?

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

Cela vérifie si la valeur arrondie du double est la même que celle du double.

Votre variable peut avoir une valeur int ou double et a Math.floor(variable)toujours une valeur int, donc si votre variable est égale à Math.floor(variable)alors elle doit avoir une valeur int.

Cela ne fonctionne pas non plus si la valeur de la variable est infinie ou infinie négative, ajoutant donc «tant que la variable n'est pas infinie» à la condition.

Ou vous pouvez utiliser l'opérateur modulo:

(d % 1) == 0

Goyave: DoubleMath.isMathematicalInteger. (Divulgation: je l'ai écrit.) Ou, si vous x == Math.rint(x)n'importez pas déjà Guava, c'est le moyen le plus rapide de le faire; rintest sensiblement plus rapide que floorou ceil.

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

Essayez de cette façon,

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

par exemple:

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

donc 12,9 n'est pas un entier, néanmoins

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

donc 12,0 est un entier

Voici une version pour Integeret 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;
    }
}

Pour convertir Doubleen Integer:

Integer intVariable = variable.intValue();

Considérer:

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

Cela colle au noyau Java et évite une comparaison d'égalité entre les valeurs en virgule flottante ( ==) qui est considérée comme mauvaise. Le isFinite()est nécessaire, tout comme les rint()valeurs infinies.

Le meilleur moyen est d'utiliser un opérateur de module

if(val % 1 == 0)

Voici une bonne solution:

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

Similaire à la réponse de SkonJeet ci-dessus, mais les performances sont meilleures (au moins en 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);
}

vous pouvez essayer de cette manière: obtenir la valeur entière du double, soustraire celle-ci de la valeur double d'origine, définir une plage d'arrondi et tester si le nombre absolu de la nouvelle valeur double (sans la partie entière) est plus grand ou plus petit que votre plage définie. s'il est plus petit, vous pouvez avoir l'intention que ce soit une valeur entière. Exemple:

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

Si vous affectez à d la valeur 33,15, la méthode renvoie true. Pour obtenir de meilleurs résultats, vous pouvez attribuer des valeurs inférieures à testRange (comme 0,0002) à votre discrétion.

Personnellement, je préfère la solution d'opération modulo simple dans la réponse acceptée. Malheureusement, SonarQube n'aime pas les tests d'égalité avec des points flottants sans définir une précision ronde. Nous avons donc essayé de trouver une solution plus conforme. C'est ici:

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

Remainder(BigDecimal)renvoie un BigDecimaldont la valeur est (this % divisor). Si celui-ci est égal à zéro, nous savons qu'il n'y a pas de virgule flottante.

Ma solution simple:

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

Voici une solution:

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