Відповідно до цієї сторінки java.sun == є оператором порівняння рівності для чисел з плаваючою комою на Java.

Однак, коли я набираю цей код:

if(sectionID == currentSectionID)

у свій редактор і запускаю статичний аналіз, я отримую: "Значення з плаваючою точкою JAVA0078 порівняно з =="

Що не так у використанні ==для порівняння значень з плаваючою комою? Який правильний спосіб це зробити? 

правильний спосіб перевірити floats на "рівність":

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

де епсилон - це дуже невелике число, наприклад 0,00000001, залежно від бажаної точності.

Значення з плаваючою комою можна трохи вимкнути, тож вони можуть не відображатись як однакові. Наприклад, встановивши поплавок на "6.1" та знову роздрукувавши його, ви можете отримати звітне значення чогось типу "6.099999904632568359375". Це є основним для способу роботи плавців; отже, ви не хочете порівнювати їх за допомогою рівності, а скоріше порівняння в межах діапазону, тобто якщо відмінність поплавця від числа, з яким ви хочете порівняти його, є меншим за певне абсолютне значення.

Ця стаття Реєстру дає хороший огляд того, чому це так; корисне та цікаве читання.

Тільки щоб дати причину тому, що всі інші говорять.

Двійкове представлення поплавця є свого роду дратівливим.

У двійковій частині більшість програмістів знають кореляцію між 1b = 1d, 10b = 2d, 100b = 4d, 1000b = 8d

Добре це працює і в інший спосіб.

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

Проблема полягає в тому, що немає точного способу представити більшість десяткових чисел, таких як .1, .2, .3 і т. Д. Все, що ви можете зробити, є приблизним у двійковій формі. Коли система друкує номери, система трохи закруглена, і вона відображає .1 замість .10000000000001 або .999999999999 (які, мабуть, так само близькі до збереженого подання, як і .1)

Редагувати з коментаря: Причиною цієї проблеми є наші очікування. Ми повністю сподіваємось, що 2/3 буде зіпсовано в якийсь момент, коли ми перетворюємо його в десяткові, або 7, або 67, або 666667 .. Але ми автоматично не очікуємо, що .1 буде округлений так само, як 2/3 - І саме це відбувається.

До речі, якщо вам цікаво число, яке воно зберігає всередині, - це чисте двійкове представлення, використовуючи двійкове "Наукове позначення". Отже, якщо ви сказали йому зберігати десяткове число 10,75d, воно буде зберігати 1010b для 10, а .11b - для десяткового. Таким чином, він буде зберігати .101011, тоді він зберігає кілька біт в кінці, щоб сказати: Перемістіть десяткову точку на чотири місця вправо.

(Хоча технічно це вже не десяткова крапка, це тепер двійкова крапка, але ця термінологія не зробила б речі зрозумілішими для більшості людей, які знайдуть цю відповідь будь-якого використання.)

Що не так з використанням == для порівняння значень з плаваючою комою?

Тому що це неправда 0.1 + 0.2 == 0.3

Я думаю, що навколо поплавків (і подвоєнь) існує велика плутанина, це добре очистити.

1. Немає нічого поганого в використанні плавців як ідентифікаторів у сумісному стандарті JVM [*]. Якщо ви просто встановите ідентифікатор float на x, нічого не робите з ним (тобто немає арифметики) і пізніше перевіряйте наявність y == x, вам все буде добре. Також немає нічого поганого в тому, щоб використовувати їх як ключі в HashMap. Що ви не можете зробити, це припустити рівності x == (x - y) + y, і т. Д. Це, як говорять, люди зазвичай використовують цілі типи як ідентифікатори, і ви можете помітити, що більшість людей тут відкладені цим кодом, тому з практичних причин краще дотримуватися конвенцій . Зауважте, що існує стільки різних doubleзначень, скільки довгих values, тому ви нічого не отримуєте, використовуючи double. Крім того, генерування "наступного наявного ідентифікатора" може бути складним з подвоєнням і вимагає певних знань арифметики з плаваючою комою. Не варто біди.

2. З іншого боку, покладатися на числову рівність результатів двох математично еквівалентних обчислень ризиковано. Це пояснюється помилками округлення та втратою точності при перетворенні від десяткового до двійкового подання. Це було обговорено на смерть на SO.

[*] Коли я сказав "JVM, сумісний зі стандартами", я хотів виключити певні реалізації JVM з пошкодженнями мозку. Дивіться це .

Ця проблема не характерна для Java. Використання == для порівняння двох поплавків / подвійних / будь-яких десяткових чисел може потенційно спричинити проблеми через спосіб їх зберігання. Одноточний поплавок (згідно стандарту 754 IEEE) має 32 біти, розподілені таким чином:

1 біт - Знак (0 = позитивний, 1 = негативний)
8 біт - Експонент (спеціальне (зміщення-127) подання x у 2 ^ x)
23 біт - Мантіса. Діючий номер, який зберігається.

Мантіса - це те, що викликає проблему. Це як би наукове позначення, лише число в базі 2 (двійкове) виглядає як 1.110011 x 2 ^ 5 або щось подібне. Але в двійковому періоді перший 1 завжди є 1 (крім представлення 0)

Тому, щоб заощадити трохи місця в пам'яті (призначений каламбур), IEEE вирішив вважати 1. Наприклад, мантія 1011 дійсно становить 1,1011.

Це може спричинити деякі проблеми порівняння, особливо з 0, оскільки 0 не може бути представлено точно поплавком. Це головна причина, що == не відштовхується, крім питань математики з плаваючою комою, описаних іншими відповідями.

У Java є унікальна проблема в тому, що мова є універсальною для багатьох різних платформ, кожна з яких може мати свій унікальний формат float. Це робить ще важливішим уникати ==.

Правильний спосіб порівняння двох плавців (не мовних специфік ви) для рівності полягає в наступному:

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

де ACCEPTABLE_ERROR є #defined або якась інша константа, що дорівнює 0,000000001 або потрібна якась точність, як уже згадував Віктор.

У деяких мовах вбудована ця функціональність або ця константа, але загалом це хороша звичка бути.

На сьогоднішній день швидкий та простий спосіб зробити це:

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

Однак у документах чітко не вказано значення різниці на полях ( епсилон з відповіді @Victor), яке завжди присутнє в обчисленнях поплавків, але воно повинно бути чимось розумним, оскільки воно є частиною стандартної мовної бібліотеки.

Але якщо потрібна більш висока або спеціальна точність, значить

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

є ще одним варіантом рішення.

Значення опорної точки не є надійними через помилку округлення.

Як такі, вони, ймовірно, не повинні використовуватися як ключові значення, такі як sectionID. Замість цього використовуйте цілі числа або longякщо intвони не містять достатньо можливих значень.

На додаток до попередніх відповідей, ви повинні знати, що існують дивні форми поведінки, пов'язані з -0.0fі +0.0f(вони є, ==але ні equals) і Float.NaN(це є, equalsале ні ==) (сподіваюся, що я маю на це правильно - аргументуйте, не робіть цього!).

Редагувати: перевіримо!

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.

Ось дуже довга (але, сподіваюся, корисна) дискусія з цього питання та багатьох інших питань з плаваючою точкою, з якими ви можете зіткнутися: Що повинен знати кожен вчений-комп'ютер про арифметику з плаваючою комою

Ви можете використовувати Float.floatToIntBits ().

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

Перш за все, вони плавають чи плавають? Якщо одним із них є Float, слід скористатися методом equals (). Також, напевно, найкраще використовувати статичний метод Float.compare.

Нижче автоматично використовується найкраща точність:

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

Звичайно, ви можете вибрати більше або менше 5 ULP ("одиниця в останньому місці").

Якщо ви перебуваєте в бібліотеці Apache Commons, то Precision клас має compareTo()і equals()epsilon, і ULP.

ви можете хочете, щоб це було ==, але 123.4444444444443! = 123.4444444444442

Якщо вам доведеться * використовувати floats, ключове слово Stroffp може бути корисним.

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

Два різні обчислення, які дають рівні дійсні числа, не обов'язково дають однакові числа з плаваючою комою. Люди, які використовують == для порівняння результатів обчислень, як правило, дивуються цим, тому попередження допомагає позначити те, що в іншому випадку може бути тонким і важким для відтворення помилки.

Чи маєте ви справу з аутсорсинговим кодом, який би використовував floats для речей, названих sectionID та currentSectionID? Просто цікаво.

@Bill K: "Двійкове представлення поплавця - це щось дратує". Як так? Як би ви зробили це краще? Є певні числа, які неможливо представити в будь-якій базі належним чином, оскільки вони ніколи не закінчуються. Пі - хороший приклад. Ви можете лише наблизити його. Якщо у вас є краще рішення, зверніться до Intel.

Як згадується в інших відповідях, парні можуть мати невеликі відхилення. І ви можете написати власний метод порівняння їх, використовуючи "прийнятне" відхилення. Однак ...

Існує клас apache для порівняння парних пар: org.apache.commons.math3.util.Precision

Він містить кілька цікавих констант: SAFE_MINіEPSILON , які є максимально можливими відхиленнями простих арифметичних операцій.

Він також забезпечує необхідні методи порівняння, рівних чи круглих парних пар. (з використанням виразки або абсолютного відхилення)

У одному рядковому відповіді, я можу сказати, ви повинні використовувати:

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

Щоб ви дізналися більше про правильне використання пов’язаних операторів, я докладно розглядаю тут деякі випадки: Як правило, є три способи тестування рядків у Java. Ви можете використовувати ==, .equals () або Objects.equals ().

Чим вони відрізняються? == тести на контрольну якість у рядках, що означає з'ясування того, чи є два об'єкти однаковими. З іншого боку, .equals () перевіряє, чи мають логічно два струни однакове значення. Нарешті, тести об’єктів.equals () для будь-яких нулів у двох рядках визначають, чи потрібно викликати .equals ().

Ідеальний оператор для використання

Ну, це було предметом багатьох дискусій, оскільки кожен з трьох операторів має свій унікальний набір сильних і слабких сторін. Наприклад, == часто є кращим варіантом при порівнянні посилань на об'єкти, але є випадки, коли може здатися, що також порівнюються значення рядків.

Однак ви отримуєте значення падіння, оскільки Java створює ілюзію, що ви порівнюєте цінності, але в реальному сенсі ви це не так. Розглянемо два випадки нижче:

Випадок 1:

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

Випадок 2:

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

Отже, краще використовувати кожного оператора при тестуванні конкретного атрибута, для якого він призначений. Але майже у всіх випадках Objects.equals () є більш універсальним оператором, тому досвід веб-розробників вибирає саме це.

Тут ви можете отримати більш детальну інформацію: http://fluentthemes.com/use-compare-strings-java/

Правильний шлях був би

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

Один із способів зменшити похибку округлення - використовувати подвійний, а не плаваючий. Це не призведе до усунення проблеми, але це зменшує кількість помилок у вашій програмі, а плаваючий майже ніколи не є найкращим вибором. ІМХО.