浮点值可能会稍有偏差，因此它们可能不会完全相等。例如，将浮点数设置为“6.1”，然后再次打印出来，可能会得到类似“6.0999999904632568359375”的报告值。这是浮动工作方式的基础;因此，您不想使用相等性来比较它们，而是要在一定范围内进行比较，也就是说，如果浮点数与要比较的数字的差异小于某个绝对值。

这篇关于登记册的文章很好地概述了为什么会这样;有用且有趣的阅读。

首先，它们是漂浮的还是漂浮的？如果其中一个是 Float，则应使用 equals（） 方法。此外，最好使用静态 Float.compare 方法。

由于舍入误差，Foating 点值不可靠。

因此，它们可能不应用作键值，例如 sectionID。请改用整数，或者如果未包含足够的可能值。longint

正确的方法是

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

测试浮点数是否“相等”的正确方法是：

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

其中 epsilon 是一个非常小的数字，如 0.00000001，具体取决于所需的精度。

您可能希望它是 ==，但是 123.44444444444443 ！= 123.4444444444442

除了之前的答案之外，您还应该意识到与 and（它们是但不是）和（它是但不是）相关的奇怪行为（希望我说得对 - 啊，不要这样做！-0.0f+0.0f==equalsFloat.NaNequals==

编辑：让我们检查一下！

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。

这里有一个很长（但希望有用）的讨论，关于这个问题和你可能遇到的许多其他浮点问题： 每个计算机科学家都应该知道的关于浮点运算的知识

只是为了给出其他人所说的话背后的原因。

浮点数的二进制表示有点烦人。

在二进制中，大多数程序员都知道 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

产生相等实数的两种不同计算不一定产生相等的浮点数。使用 == 比较计算结果的人通常最终会对此感到惊讶，因此警告有助于标记可能是一个微妙且难以重现的错误。

您是否正在处理将浮点数用于名为 sectionID 和 currentSectionID 的事物的外包代码？只是好奇。

@Bill K：“浮点数的二进制表示有点烦人。怎么会这样？你会如何做得更好？有些数字不能在任何基数中正确表示，因为它们永无止境。Pi 就是一个很好的例子。你只能近似它。如果您有更好的解决方案，请联系英特尔。

这不是一个特定于 java 的问题。使用 == 比较两个浮点数/双精度数/任何十进制类型的数字可能会导致问题，因为它们的存储方式。 单精度浮点数（根据 IEEE 标准 754）有 32 位，分布如下：

1 位 - 符号（0 = 正数，1 = 负数） 8 位 - 指数（2^x 中 x 的特殊 （bias-127） 表示）

23 位 - 螳螂。存储的实际数字。

螳螂是导致问题的原因。这有点像科学记数法，只有以 2 为基数（二进制）的数字看起来像 1.110011 x 2^5 或类似的东西。 但在二进制中，第一个 1 始终是 1（除了 0 的表示）

因此，为了节省一点内存空间（双关语），IEEE认为应该假设1。例如，螳螂 1011 实际上是 1.1011。

这可能会导致比较出现一些问题，尤其是 0，因为 0 不可能在浮点数中准确表示。 这是不鼓励使用 == 的主要原因，此外还有其他答案描述的浮点数学问题。

Java 有一个独特的问题，因为该语言在许多不同的平台上是通用的，每个平台都可以有自己独特的浮点格式。这使得避免 == 变得更加重要。

比较两个浮点数（请注意，非特定于语言）的相等的正确方法如下：

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

其中 ACCEPTABLE_ERROR 是 #defined 或其他等于 0.000000001 的常数或所需的任何精度，正如 Victor 已经提到的。

有些语言内置了此功能或常量，但通常这是一个好习惯。

我认为围绕浮动（和双打）有很多混淆，最好弄清楚它。

1. 在符合标准的 JVM 中使用浮点数作为 ID 本身并没有错 [*]。如果你只是将浮点 ID 设置为 x，什么都不用做（即不做算术），然后测试 y == x，你会没事的。此外，将它们用作 HashMap 中的键也没有错。你不能做的是假设等式，比如 等。话虽如此，人们通常使用整数类型作为 ID，您可以观察到这里的大多数人都对这段代码望而却步，因此出于实际原因，最好遵守约定。请注意，有多少个不同的值，有多少个 long ，因此使用 .此外，生成“下一个可用 ID”对于双精度计算可能很棘手，并且需要一些浮点运算知识。不值得麻烦。x == (x - y) + ydoublevaluesdouble

2. 另一方面，依靠两个数学上等效的计算结果的数值相等是有风险的。这是因为从十进制表示转换为二进制表示时存在舍入误差和精度损失。这在 SO 上已经讨论得死去活来。

[*]当我说“符合标准的 JVM”时，我想排除某些脑损伤的 JVM 实现。看这个。

减少舍入误差的一种方法是使用 double 而不是 float。这不会使问题消失，但它确实减少了程序中的错误量，而浮点几乎从来都不是最佳选择。恕我直言。

如果您*必须*使用浮点数，strictfp 关键字可能很有用。

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

您可以使用 Float.floatToIntBits（）。

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

以下项会自动使用最佳精度：

/**
 * 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 库，则该类同时具有 epsilon 和 ULP。PrecisioncompareTo()equals()

正如其他答案中提到的，双打可能会有很小的偏差。你可以编写自己的方法，使用“可接受的”偏差来比较它们。然而。。。

有一个用于比较双精度的 apache 类：org.apache.commons.math3.util.Precision

它包含一些有趣的常数： 和 ，它们是简单算术运算的最大可能偏差。SAFE_MINEPSILON

它还提供了比较、相等或四舍五入双精度的必要方法。（使用 ULP 或绝对偏差）

在一行答案中，我可以说，你应该使用：

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

为了让您更多地了解正确使用相关运算符，我在这里详细阐述了一些案例： 一般来说，在 Java 中测试字符串有三种方法。可以使用 ==、.equals （） 或 Objects.equals （）。

它们有何不同？== 测试字符串中的参考质量，这意味着找出两个对象是否相同。另一方面，.equals（） 测试两个字符串在逻辑上是否具有相等的值。最后，Objects.equals（） 测试两个字符串中的任何 null，然后确定是否调用 .equals （）。

理想的操作员

嗯，这引起了很多争论，因为这三家运营商中的每一个都有其独特的优势和劣势。例如，在比较对象引用时，== 通常是首选选项，但在某些情况下，它似乎也会比较字符串值。

然而，你得到的是一个下降值，因为 Java 创造了一种错觉，即你正在比较值，但实际上你不是。请考虑以下两种情况：

案例一：

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

案例二：

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

因此，在测试每个运算符设计的特定属性时，最好使用每个运算符。但在几乎所有情况下，Objects.equals（） 都是一个更通用的运算符，因此有经验的 Web 开发人员会选择它。

在这里，您可以获得更多详细信息： http://fluentthemes.com/use-compare-strings-java/

到今天为止，快速简便的方法是：

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

但是，文档没有明确指定在浮点数计算中始终存在的边距差值（来自 @Victor 的答案中的 epsilon），但它应该是合理的，因为它是标准语言库的一部分。

然而，如果需要更高或定制的精度，那么

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

是另一种解决方案选项。