Jak sprawdzić, czy double jest liczbą całkowitą

Czy da się to zrobić?

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
}

Wiem, że kod prawdopodobnie nie działa w ten sposób, ale jak to działa ?

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

Sprawdza, czy zaokrąglona w dół wartość double jest taka sama jak double.

Twoja zmienna może mieć wartość int lub double i Math.floor(variable)zawsze mieć wartość int, więc jeśli zmienna jest równa, Math.floor(variable)to musi mieć wartość int.

To również nie działa, jeśli wartość zmiennej jest nieskończona lub ujemna nieskończona, dlatego do warunku dodaje się „tak długo, jak zmienna nie jest nieskończona”.

Lub możesz użyć operatora modulo:

(d % 1) == 0

Guawa: DoubleMath.isMathematicalInteger. (Ujawnienie: napisałem to.) Lub, jeśli jeszcze nie importujesz guawy, x == Math.rint(x)jest to najszybszy sposób na zrobienie tego; rintjest mierzalnie szybszy niż floorlub ceil.

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

Spróbuj w ten sposób

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

na przykład:

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

stąd 12,9 nie jest jednak liczbą całkowitą

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

stąd 12,0 jest liczbą całkowitą

Oto wersja dla Integeri 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;
    }
}

Aby przekonwertować Doublena Integer:

Integer intVariable = variable.intValue();

Rozważać:

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

To trzyma się rdzenia Javy i pozwala uniknąć porównania równości między wartościami zmiennoprzecinkowymi ( ==), które są uważane za złe. Jest isFinite()to konieczne, podobnie jak rint()wartości nieskończoności.

Najlepszym sposobem jest użycie operatora modułu

if(val % 1 == 0)

Oto dobre rozwiązanie:

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

Podobna do odpowiedzi SkonJeeta powyżej, ale wydajność jest lepsza (przynajmniej w Javie):

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

możesz spróbować w ten sposób: pobierz wartość całkowitą double, odejmij ją od pierwotnej wartości double, zdefiniuj zakres zaokrąglania i sprawdź, czy liczba bezwzględna nowej wartości double (bez części całkowitej) jest większa lub mniejsza niż twoja zdefiniowany zakres. jeśli jest mniejszy, możesz zamierzyć, że jest to wartość całkowita. Przykład:

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

Jeśli przypiszesz d wartość 33,15, metoda zwróci wartość true. Aby uzyskać lepsze wyniki, możesz według własnego uznania przypisać niższe wartości testRange (jako 0,0002).

Osobiście wolę proste rozwiązanie obsługi modulo w przyjętej odpowiedzi. Niestety SonarQube nie lubi testów równości z zmiennoprzecinkowymi bez ustawiania okrągłej precyzji. Dlatego staraliśmy się znaleźć bardziej zgodne rozwiązanie. Oto ona:

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

Remainder(BigDecimal)zwraca a, BigDecimalktórego wartość to (this % divisor). Jeśli ta jest równa zero, wiemy, że nie ma zmiennoprzecinkowego.

Moje proste rozwiązanie:

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

Oto rozwiązanie:

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