Bir çiftin bir tam sayı olup olmadığını test etme

Bunu yapmak mümkün mü?

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
}

Ben kod muhtemelen böyle bir şey gitmez biliyorum ama nasıl yok gitti?

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

Bu, çiftin yuvarlatılmış değerinin çiftle aynı olup olmadığını kontrol eder.

Değişkeninizin int veya çift değeri olabilir ve Math.floor(variable)her zaman int değeri olabilir, bu nedenle değişkeniniz eşitse Math.floor(variable)int değerine sahip olmalıdır.

Bu, değişkenin değeri sonsuz veya negatif sonsuzsa da işe yaramaz, bu nedenle koşula 'değişken sonsuz olmadığı sürece' eklenir.

Veya modulo operatörünü kullanabilirsiniz:

(d % 1) == 0

Guava: DoubleMath.isMathematicalInteger. (Açıklama: Yazdım.) Ya da, zaten Guava'yı ithal x == Math.rint(x)etmiyorsanız, bunu yapmanın en hızlı yolu; rintölçülebilir şekilde floorveya değerinden daha hızlıdır ceil.

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

Bu şekilde dene,

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

Örneğin:

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

dolayısıyla 12.9 olduğu değil yine de, tam sayı

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

dolayısıyla 12.0 tam sayıdır

İşte Integerve için bir sürüm 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;
    }
}

Dönüştürmek Doubleiçin Integer:

Integer intVariable = variable.intValue();

Düşünmek:

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

Bu, çekirdek Java'ya yapışır ve kayan nokta değerleri ( ==) arasında kötü olarak değerlendirilen bir eşitlik karşılaştırmasını önler . isFinite()Gerekli olan rint()geçiş olacak sonsuz değerleri.

En iyi yol, modül operatörü ile

if(val % 1 == 0)

İşte iyi bir çözüm:

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

SkonJeet'in yukarıdaki cevabına benzer, ancak performans daha iyi (en azından java'da):

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

bu şekilde deneyebilirsiniz: çiftin tamsayı değerini alın, bunu orijinal çift değerden çıkarın, bir yuvarlama aralığı tanımlayın ve yeni çift değerin mutlak sayısının (tamsayı kısmı olmadan) tanımlı aralık. daha küçükse, bir tamsayı değerdir. Misal:

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

D'ye 33.15 değerini atarsanız, yöntem true değerini döndürür. Daha iyi sonuçlar elde etmek için, takdirinize bağlı olarak testRange'a (0.0002 olarak) daha düşük değerler atayabilirsiniz.

Şahsen, kabul edilen cevapta basit modulo operasyon çözümünü tercih ediyorum. Ne yazık ki, SonarQube yuvarlak bir hassasiyet ayarlamadan kayan noktalı eşitlik testlerini sevmez. Bu yüzden daha uyumlu bir çözüm bulmaya çalıştık. İşte burada:

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

Remainder(BigDecimal)BigDecimaldeğeri olan bir değeri döndürür (this % divisor). Eğer bu sıfıra eşitse, kayan nokta olmadığını biliyoruz.

Benim basit çözümüm:

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

İşte bir çözüm:

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