Bu java.sun sayfasına göre ==Java'da kayan nokta sayıları için eşitlik karşılaştırma operatörüdür.

Ancak, bu kodu yazarken:

if(sectionID == currentSectionID)

benim editörü içine ve statik analiz çalıştırmak, elde: "JAVA0078 = = ile karşılaştırıldığında kayan nokta değerleri"

==Kayan nokta değerlerini karşılaştırmak için kullanmanın yanlışlığı nedir ? Bunu yapmanın doğru yolu nedir? 

şamandıraları 'eşitlik' için test etmenin doğru yolu:

if(Math.abs(sectionID - currentSectionID) < epsilon)

Burada epsilon, istenen hassasiyete bağlı olarak 0.00000001 gibi çok küçük bir sayıdır.

Kayan nokta değerleri bir miktar kapalı olabilir, bu nedenle tam olarak eşit olarak rapor edilmeyebilirler. Örneğin, bir kayan noktayı "6.1" olarak ayarlayıp tekrar basmak, "6.099999904632568359375" gibi bir şeyin rapor edilen değerini alabilirsiniz. Bu, şamandıraların çalışması için esastır; bu nedenle, onları eşitlik kullanarak karşılaştırmak istemezsiniz, daha ziyade bir aralık içindeki karşılaştırma, yani şamandıranın karşılaştırmak istediğiniz sayıya olan farkı belirli bir mutlak değerden daha azsa.

Kayıttaki bu makale, durumun neden böyle olduğuna dair iyi bir genel bakış sunmaktadır; yararlı ve ilginç okuma.

Sadece herkesin söylediklerinin arkasındaki sebebi belirtmek için.

Bir şamandıranın ikili temsili biraz sinir bozucudur.

İkili programcıların çoğu, 1b = 1d, 10b = 2d, 100b = 4d, 1000b = 8d arasındaki korelasyonu bilir

Peki başka bir şekilde çalışıyor.

.1b = .5d, .01b = .25d, .001b = .125, ...

Sorun, .1, .2, .3 vb. Gibi çoğu ondalık sayıyı temsil etmenin kesin bir yolu olmamasıdır. Sayılar yazdırıldığında sistem biraz yuvarlama yapar, böylece .10000000000001 veya .999999999999 yerine .1 görüntülenir (muhtemelen depolanan gösterime .1 kadar yakındır)

Yorumdan düzenle: Bunun bir sorun olmasının nedeni beklentilerimiz. .7 ya da .67 ya da .666667'yi ondalık sayıya dönüştürdüğümüzde 2/3'ün bir noktada tamamen yumuşatılmasını bekliyoruz. Ancak .1'in 2/3 ile aynı şekilde yuvarlanmasını beklemiyoruz. - ve tam olarak olan bu.

Bu arada, dahili olarak sakladığı sayıyı merak ediyorsanız, bir ikili "Bilimsel Gösterim" kullanan saf bir ikili gösterimdir. Eğer ondalık sayı 10.75d saklamasını söylediyseniz, 10 için 1010b ve ondalık için .11b saklar. Yani .101011'i saklardı ve sonunda birkaç bit kaydeder: Ondalık noktasını dört basamak sağa hareket ettirir.

(Teknik olarak artık ondalık bir nokta olmamasına rağmen, şimdi bir ikili nokta, ancak bu terminoloji, herhangi bir kullanımın bu cevabını bulan çoğu insan için işleri daha anlaşılır yapmazdı.)

Kayan nokta değerlerini karşılaştırmak için == kullanmanın sorunu nedir?

Çünkü bu doğru değil 0.1 + 0.2 == 0.3

Bence şamandıralar (ve çiftler) etrafında çok fazla karışıklık var, onu temizlemek iyi.

1. Standart uyumlu JVM'de şamandıraların kimlik olarak kullanılmasında doğası gereği yanlış bir şey yoktur [*]. Şamandıra kimliğini x olarak ayarladıysanız, onunla hiçbir şey yapmayın (yani aritmetik yok) ve daha sonra y == x için test edin, iyi olacaksınız. Ayrıca bunları HashMap'te anahtar olarak kullanmada yanlış bir şey yoktur. Yapamayacağınız şey x == (x - y) + y, vb. Eşitlikler olduğunu varsaymaktır . Buna göre, insanlar genellikle tamsayı tiplerini kimlik olarak kullanırlar ve buradaki çoğu insanın bu kod tarafından ertelendiğini gözlemleyebilirsiniz, bu yüzden pratik nedenlerle, sözleşmelere uymak daha iyidir . Uzun olduğu kadar çok farklı doubledeğer olduğuna dikkat edin values, böylece kullanarak hiçbir şey kazanamazsınız double. Ayrıca, "bir sonraki kullanılabilir kimlik" oluşturmak iki kat ile zor olabilir ve kayan nokta aritmetiği hakkında biraz bilgi gerektirir. Sorun değil.

2. Öte yandan, iki matematiksel olarak denk hesaplamanın sonuçlarının sayısal eşitliğine güvenmek risklidir. Bunun nedeni, yuvarlama hataları ve ondalıktan ikili gösterime dönüştürürken hassasiyet kaybıdır. Bu SO üzerinde ölümle tartışıldı.

[*] “Standart uyumlu JVM” dediğimde, beyinden zarar görmüş bazı JVM uygulamalarını hariç tutmak istedim. Bkz bu .

Bu, java'ya özgü olmayan bir sorundur. İki şamandırası / iki katı / herhangi bir ondalık tip numarasını karşılaştırmak için == kullanmak, depolanma biçimleri nedeniyle sorunlara neden olabilir. Tek hassasiyetli bir şamandıra (IEEE standardı 754'e göre) aşağıdaki gibi dağıtılan 32 bite sahiptir:

1 bit - İşaret (0 = pozitif, 1 = negatif)
8 bit - Üstel (2 ^ x içinde x'in özel (önyargı-127) gösterimi)
23 bit - Mantisa. Kaydedilen gerçek sayı.

Soruna mantisa neden olur. Bilimsel gösterim gibi, sadece taban 2'deki (ikili) sayı 1.110011 x 2 ^ 5 veya benzer bir şeye benziyor. Ancak ikili dosyada, ilk 1 her zaman 1'dir (0'ın temsili hariç)

Bu nedenle, biraz hafıza alanı kazanmak için (pun amaçlı), IEEE 1'in kabul edilmesi gerektiğine karar verdi. Örneğin, 1011'lik bir mantis gerçekten 1.1011'dir.

Bu, karşılaştırma ile bazı sorunlara neden olabilir, özellikle 0 ile, 0 muhtemelen bir şamandırada tam olarak temsil edilemez. Bu, diğer cevaplar tarafından açıklanan kayan nokta matematik konularına ek olarak == 'ın cesaret kırılmasının ana nedenidir.

Java, dilin her biri kendi benzersiz şamandıra biçimine sahip olabilen birçok farklı platformda evrensel olması bakımından benzersiz bir soruna sahiptir. Bu == 'dan kaçınmayı daha da önemli hale getirir.

Eşitlik için iki şamandırayı (dile özgü olmayan zihin) karşılaştırmanın doğru yolu aşağıdaki gibidir:

if(ABS(float1 - float2) < ACCEPTABLE_ERROR)
    //they are approximately equal

burada ACCEPTABLE_ERROR #defined ya da Victor'un belirttiği gibi 0,000000001'e eşit veya başka bir hassasiyete ihtiyaç duyar.

Bazı diller bu işlevselliğe veya bu sabit yerleşik olarak bulunur, ancak genellikle bu iyi bir alışkanlıktır.

Bugün itibariyle bunu yapmanın hızlı ve kolay yolu:

if (Float.compare(sectionID, currentSectionID) == 0) {...}

Ancak dokümanlar , kenar boşluğu farkının değerini açıkça belirtmez (bir epsilon) , kayan nokta hesaplamalarında her zaman bulunan @Victor yanıtından , ancak standart dil kütüphanesinin bir parçası olduğu için makul bir şey olmalıdır.

Yine de daha yüksek veya özelleştirilmiş bir hassasiyet gerekiyorsa,

float epsilon = Float.MIN_NORMAL;  
if(Math.abs(sectionID - currentSectionID) < epsilon){...}

başka bir çözüm seçeneğidir.

Kayan nokta değerleri nedeniyle kayan nokta değerleri güvenilir değildir.

Bu nedenle, bunlar büyük olasılıkla sectionID gibi anahtar değerler olarak kullanılmamalıdır. Bunun yerine tamsayılar kullanın veya longeğer intyeterince olası değerleri içermiyor.

Önceki cevaplara ek olarak, ilişkili garip davranışlar olduğunu bilmelidir -0.0fve +0.0f(onlar ==değil equals) ve Float.NaN(öyle equalsdeğil== ) (umut doğru olduğunu var! - argh bunu yapmayın).

Düzenleme: Kontrol edelim!

import static java.lang.Float.NaN;
public class Fl {
    public static void main(String[] args) {
        System.err.println(          -0.0f   ==              0.0f);   // true
        System.err.println(new Float(-0.0f).equals(new Float(0.0f))); // false
        System.err.println(            NaN   ==               NaN);   // false
        System.err.println(new Float(  NaN).equals(new Float( NaN))); // true
    }
} 

IEEE / 754'e hoş geldiniz.

İşte bu ve karşılaşabileceğiniz diğer pek çok kayan nokta sorunu hakkında çok uzun (ama umarım faydalı) bir tartışma: Her Bilgisayar Bilimcisinin Kayan Nokta Aritmetiği Hakkında Bilmesi Gerekenler

Float.floatToIntBits () öğesini kullanabilirsiniz.

Float.floatToIntBits(sectionID) == Float.floatToIntBits(currentSectionID)

Her şeyden önce, yüzüyorlar mı yoksa yüzüyorlar mı? Bunlardan biri bir Float ise, equals () yöntemini kullanmalısınız. Ayrıca, muhtemelen en iyi statik Float.compare yöntemini kullanmaktır.

Aşağıdakiler otomatik olarak en iyi hassasiyeti kullanır:

/**
 * Compare to floats for (almost) equality. Will check whether they are
 * at most 5 ULP apart.
 */
public static boolean isFloatingEqual(float v1, float v2) {
    if (v1 == v2)
        return true;
    float absoluteDifference = Math.abs(v1 - v2);
    float maxUlp = Math.max(Math.ulp(v1), Math.ulp(v2));
    return absoluteDifference < 5 * maxUlp;
}

Tabii ki, 5'den fazla veya daha az ULP ('son yerde birim') seçebilirsiniz.

Apache Commons kütüphaneye iseniz, Precisionsınıf vardır compareTo()ve equals()epsilon ve ULP ikisi ile.

== olmasını isteyebilirsiniz, ancak 123.4444444444443! = 123.4444444444442

Şamandıra * kullanmanız * gerekiyorsa, strictfp anahtar sözcüğü yararlı olabilir.

http://en.wikipedia.org/wiki/strictfp

Eşit gerçek sayılar üreten iki farklı hesaplama mutlaka eşit kayan nokta sayıları üretmez. Hesaplama sonuçlarını karşılaştırmak için == kullanan insanlar genellikle buna şaşırırlar, bu nedenle uyarı, aksi takdirde ince ve yeniden üretilmesi zor olabilecek şeyleri işaretlemeye yardımcı olur.

SectionID ve currentSectionID adlı şeyler için şamandıraları kullanacak dış kaynak koduyla mı uğraşıyorsunuz? Sadece merak.

@ Fatura K: "Bir şamandıranın ikili temsili biraz sinir bozucu." Nasıl yani? Nasıl daha iyi yapardın? Hiçbir şekilde düzgün bir şekilde temsil edilemeyen bazı sayılar vardır, çünkü asla bitmezler. Pi buna iyi bir örnek. Sadece tahmin edebilirsiniz. Daha iyi bir çözümünüz varsa Intel ile iletişim kurun.

Diğer cevaplarda belirtildiği gibi, çiftler küçük sapmalara sahip olabilir. Ve bunları "kabul edilebilir" bir sapma kullanarak karşılaştırmak için kendi yönteminizi yazabilirsiniz. Ancak ...

Çiftleri karşılaştırmak için bir apache sınıfı vardır: org.apache.commons.math3.util.Precision

Bazı ilginç sabitler içerir: SAFE_MINve EPSILONbasit aritmetik işlemlerin olası maksimum sapmalarıdır.

Ayrıca çiftleri karşılaştırmak, eşitlemek veya yuvarlaklaştırmak için gerekli yöntemleri sağlar. (ulps veya mutlak sapma kullanarak)

Bir satır cevap söyleyebilirim, kullanmalısınız:

Float.floatToIntBits(sectionID) == Float.floatToIntBits(currentSectionID)

İlgili işleçleri doğru bir şekilde kullanma hakkında daha fazla bilgi edinmek için, burada bazı durumları ayrıntılı olarak açıklarım: Genel olarak, Java'da dizeleri test etmenin üç yolu vardır. ==, .equals () veya Objects.equals () kullanabilirsiniz.

Nasıl farklılar? == Dizelerde referans kalitesi için testler, yani iki nesnenin aynı olup olmadığını bulma. Öte yandan, .equals () yöntemi, iki dizenin mantıksal olarak eşit değerde olup olmadığını test eder. Son olarak, Objects.equals () yöntemi, iki dizedeki null değerleri test eder.

Kullanmak için ideal operatör

Bu çok sayıda tartışmaya maruz kaldı çünkü üç operatörün her birinin kendine özgü güçlü ve zayıf yanları var. Örnek, == genellikle nesne başvurusunu karşılaştırırken tercih edilen bir seçenektir, ancak dize değerlerini de karşılaştırabileceği durumlar vardır.

Ancak, aldığınız şey bir düşme değeridir, çünkü Java değerleri karşılaştırdığınız bir yanılsama yaratır, ancak gerçek anlamda değildir. Aşağıdaki iki durumu düşünün:

Dava 1:

String a="Test";
String b="Test";
if(a==b) ===> true

Durum 2:

String nullString1 = null;
String nullString2 = null;
//evaluates to true
nullString1 == nullString2;
//throws an exception
nullString1.equals(nullString2);

Bu nedenle, tasarlanmış olduğu belirli bir özelliği test ederken her bir operatörü kullanmak daha iyidir. Ancak neredeyse her durumda, Objects.equals () daha evrensel bir operatördür, bu nedenle web geliştiricilerinin bunu tercih ettiğini deneyimleyin.

Burada daha fazla bilgi edinebilirsiniz: http://fluentthemes.com/use-compare-strings-java/

Doğru yol

java.lang.Float.compare(float1, float2)

Yuvarlama hatasını azaltmanın bir yolu şamandıra yerine çift kullanmaktır. Bu, sorunu ortadan kaldırmaz, ancak programınızdaki hata miktarını azaltır ve şamandıra neredeyse hiçbir zaman en iyi seçim değildir. BENİM NACİZANE FİKRİME GÖRE.