Согласно этой странице java.sun == является оператором сравнения равенства для чисел с плавающей точкой в ​​Java.

Тем не менее, когда я набираю этот код:

if(sectionID == currentSectionID)

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

Что плохого в использовании ==для сравнения значений с плавающей запятой? Как правильно это сделать? 

правильный способ проверить поплавки на «равенство»:

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, совместимой со стандартами [*]. Если вы просто установите для плавающего идентификатора значение x, ничего с этим не сделаете (то есть без арифметики) и позже проверите для y == x, все будет хорошо. Также нет ничего плохого в использовании их в качестве ключей в HashMap. Что вы не можете сделать, так это предположить равенство и x == (x - y) + yт. Д. При этом люди обычно используют целочисленные типы в качестве идентификаторов, и вы можете заметить, что большинство людей здесь откладывают этот код, поэтому по практическим соображениям лучше придерживаться соглашений , Обратите внимание, что существует столько же различных doubleзначений, сколько и long values, поэтому вы ничего не получите, используя double. Кроме того, создание «следующего доступного идентификатора» может быть сложным с двойными числами и требует некоторых знаний арифметики с плавающей точкой. Не стоит хлопот.

2. С другой стороны, полагаться на численное равенство результатов двух математически эквивалентных вычислений рискованно. Это связано с ошибками округления и потерей точности при преобразовании из десятичного в двоичное представление. Это было обсуждено до смерти на SO.

[*] Когда я сказал «стандартная JVM», я хотел исключить некоторые реализации JVM с поврежденным мозгом. Смотрите это .

Это проблема не только для Java. Использование == для сравнения двух чисел с плавающей запятой / двойных / любого десятичного числа может потенциально вызвать проблемы из-за способа их хранения. Число с плавающей запятой одинарной точности (согласно стандарту IEEE 754) имеет 32 бита, распределенных следующим образом:

1 бит - знак (0 = положительный, 1 = отрицательный)
8 бит - экспонента (специальное (смещение-127) представление x в 2 ^ x)
23 бита - Mantisa. Фактический номер, который сохраняется.

Богомол - то, что вызывает проблему. Это похоже на научную запись, только число в базе 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

Если вам * нужно * использовать поплавки, может пригодиться ключевое слово strictfp.

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

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

Имеете ли вы дело с внешним кодом, который будет использовать числа с плавающей запятой для вещей с именами sectionID и currentSectionID? Просто любопытно.

@ Билл К: «Бинарное представление с плавающей точкой раздражает». Как так? Как бы вы сделали это лучше? Есть определенные числа, которые не могут быть представлены в любой базе должным образом, потому что они никогда не заканчиваются. Пи хороший пример. Вы можете только приблизить это. Если у вас есть лучшее решение, обратитесь в Intel.

Как упоминалось в других ответах, двойники могут иметь небольшие отклонения. И вы можете написать свой собственный метод, чтобы сравнить их, используя «приемлемое» отклонение. Тем не мение ...

Существует класс apache для сравнения двойников: org.apache.commons.math3.util.Precision

Он содержит несколько интересных констант: SAFE_MINи EPSILON, которые являются максимально возможными отклонениями простых арифметических операций.

Он также предоставляет необходимые методы для сравнения, равенства или округления двойных чисел. (используя ulps или абсолютное отклонение)

В одной строке ответа я могу сказать, вы должны использовать:

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

Чтобы вы больше узнали о правильном использовании связанных операторов, я рассмотрю здесь несколько случаев: как правило, есть три способа тестирования строк в Java. Вы можете использовать ==, .equals () или Objects.equals ().

Насколько они разные? == проверяет эталонное качество в строках, что означает, что два объекта одинаковы. С другой стороны, .equals () проверяет, имеют ли две строки одинаковое значение логически. Наконец, Objects.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)

Один из способов уменьшить ошибку округления - использовать double, а не float. Это не устранит проблему, но уменьшит количество ошибок в вашей программе, и float почти никогда не будет лучшим выбором. ПО МОЕМУ МНЕНИЮ.