So testen Sie, ob ein Double eine Ganzzahl ist

Ist das möglich?

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
}

Ich weiß, dass der Code wahrscheinlich nicht so aussieht, aber wie geht es?

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

Dies prüft, ob der abgerundete Wert des Double mit dem Double identisch ist.

Ihre Variable kann einen int- oder double-Wert haben und hat Math.floor(variable)immer einen int-Wert. Wenn Ihre Variable also gleich ist, Math.floor(variable)muss sie einen int-Wert haben.

Dies funktioniert auch nicht, wenn der Wert der Variablen unendlich oder negativ unendlich ist, und fügt der Bedingung daher hinzu, dass die Variable nicht unendlich ist.

Oder Sie können den Modulo-Operator verwenden:

(d % 1) == 0

Guave : DoubleMath.isMathematicalInteger. (Offenlegung: Ich habe es geschrieben.) Oder, wenn Sie Guava noch nicht importieren, x == Math.rint(x)ist dies der schnellste Weg. rintist messbar schneller als flooroder ceil.

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

Versuchen Sie es so,

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

beispielsweise:

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

daher 12,9 ist nicht ganzzahlig, dennoch

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

daher ist 12.0 eine ganze Zahl

Hier ist eine Version für Integerund 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;
    }
}

So konvertieren Sie Doublezu Integer:

Integer intVariable = variable.intValue();

Erwägen:

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

Dies bleibt bei Kern-Java und vermeidet einen Gleichheitsvergleich zwischen Gleitkommawerten ( ==), der als schlecht eingestuft wird. Dies isFinite()ist notwendig, ebenso rint()wie Durchgangs-Unendlichkeitswerte.

Der beste Weg ist mit Modul Operator

if(val % 1 == 0)

Hier ist eine gute Lösung:

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

Ähnlich wie bei SkonJeets Antwort oben, aber die Leistung ist besser (zumindest 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);
}

Sie können dies folgendermaßen versuchen: Ermitteln Sie den ganzzahligen Wert des Doppelten, subtrahieren Sie diesen vom ursprünglichen doppelten Wert, definieren Sie einen Rundungsbereich und testen Sie, ob die absolute Zahl des neuen doppelten Werts (ohne den ganzzahligen Teil) größer oder kleiner als Ihr Wert ist definierter Bereich. Wenn es kleiner ist, können Sie es beabsichtigen, es ist ein ganzzahliger Wert. Beispiel:

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

Wenn Sie d den Wert 33.15 zuweisen, gibt die Methode true zurück. Um bessere Ergebnisse zu erzielen, können Sie testRange nach eigenem Ermessen niedrigere Werte (als 0,0002) zuweisen.

Persönlich bevorzuge ich die einfache Modulo-Operationslösung in der akzeptierten Antwort. Leider mag SonarQube keine Gleichheitstests mit Gleitkommawerten, ohne eine runde Genauigkeit festzulegen. Deshalb haben wir versucht, eine konformere Lösung zu finden. Hier ist es:

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

Remainder(BigDecimal)gibt a zurück, BigDecimaldessen Wert ist (this % divisor). Wenn dies gleich Null ist, wissen wir, dass es keinen Gleitkomma gibt.

Meine einfache Lösung:

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

Hier ist eine Lösung:

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