web-dev-qa-db-fra.com

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 ça marche ça va?

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

Ceci 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 Math.floor(variable) a toujours une valeur int. Par conséquent, si votre variable est égale à Math.floor(variable), sa valeur doit être int.

Cela ne fonctionne pas non plus si la valeur de la variable est infinie ou infinie négative, d'où l'ajout de "tant que la variable n'est pas inifinite" à la condition.

129
maxhud

Ou vous pouvez utiliser l'opérateur modulo:

(d % 1) == 0

190
SkonJeet

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

80
Louis Wasserman
public static boolean isInt(double d)
{
    return d == (int) d;
}
18
Eng.Fouad

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 est not entier, néanmoins

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

donc 12. est un entier

4
Sheldon

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 à virgule flottante (==) qui est considérée comme mauvaise. La isFinite() est nécessaire car rint() transmettra des valeurs à l'infini.

2
simon.watts

Semblable à la réponse de SkonJeet ci-dessus, mais les performances sont meilleures (du moins en Java):

Double zero = 0d;    
zero.longValue() == zero.doubleValue()
2
edwardsayer
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);
}
1
maerics

Voici une bonne solution:

if ((bool)(variable == (int)variable)) {
    //logic
}
1
Nitish

Voici une version pour Integer et 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 Double en Integer:

Integer intVariable = variable.intValue();
1
irudyak

vous pouvez essayer de cette façon: obtenez la valeur entière du double, soustrayez-la de la valeur double originale, définissez une plage d'arrondi et testez si le nombre absolu de la nouvelle valeur double (sans la partie entière) est supérieur ou inférieur à votre valeur. plage définie. si elle est plus petite, vous pouvez l’entendre, c’est 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 attribuez à d la valeur 33.15, la méthode retourne true. Pour obtenir de meilleurs résultats, vous pouvez attribuer des valeurs inférieures à testRange (à 0,0002) à votre discrétion.

0
Salvi94

La meilleure façon est avec l'opérateur de module

if(val % 1 == 0)
0
Abdul Hafeez Khan

Personnellement, je préfère la solution de fonctionnement modulo simple dans la réponse acceptée. Malheureusement, SonarQube n'aime pas les tests d'égalité à virgule flottante sans définir une précision arrondie. 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 une BigDecimal dont la valeur est (this % divisor). Si celui-ci est égal à zéro, nous savons qu'il n'y a pas de virgule flottante.

0
chaeschuechli