根据此java.sun页面，它 ==是Java中浮点数的相等比较运算符。

但是，当我键入以下代码时：

if(sectionID == currentSectionID)

进入编辑器并运行静态分析，我得到：“ JAVA0078与==”相比的浮点值

什么是错的使用==比较浮点值？正确的方法是什么？ 

测试浮标“相等”的正确方法是：

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

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

浮点值可能会稍微偏离一点，因此它们的报告可能并不完全相等。例如，将浮点数设置为“ 6.1”，然后再次打印出来，则可能会得到报告值，例如“ 6.099999904632568359375”。这是浮动工作方式的基础。因此，您不希望使用相等性来比较它们，而是要在一定范围内进行比较，即，如果float与要比较的数字之间的差异小于某个绝对值。

寄存器上的这篇文章很好地概述了为什么会这样。有用和有趣的阅读。

只是为了说明其他所有人在说什么的原因。

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

以二进制形式，大多数程序员都知道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）和0.11b（代表十进制）。因此，它将存储.101011，然后在末尾节省一些内容，即：将小数点右移四位。

（尽管从技术上讲，它不再是小数点，而现在是二进制点，但是对于大多数会发现任何用例的人来说，该术语都不会使事情更容易理解。）

使用==比较浮点值有什么问题？

因为那不是真的 0.1 + 0.2 == 0.3

我认为彩车（和双打）周围存在很多混乱，将其清除是一件好事。

1. 在符合标准的JVM [*] 中使用浮点数作为ID并没有本质上的错误。如果仅将float ID设置为x，则不对其进行任何处理（即不进行任何算术运算），然后再测试y == x，就可以了。在HashMap中使用它们作为键也没有错。您不能做的是假设x == (x - y) + y等式等于，等等。也就是说，人们通常使用整数类型作为ID，并且您可以看到这里的大多数人都被此代码推迟了，因此出于实际原因，最好遵守约定。请注意，double值和long一样多values。因此，使用不会获得任何收益double。同样，生成“下一个可用ID”可能很麻烦，需要使用双精度，并且需要一些浮点运算的知识。不值得的麻烦。

2. 另一方面，依靠两个数学上等效的计算结果的数值相等是冒险的。这是由于从十进制转换为二进制表示时的舍入误差和精度损失。在SO上对此进行了讨论。

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

这不是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

如Victor所述，其中ACCEPTABLE_ERROR是#defined或其他等于0.000000001的常数或要求的精度。

某些语言具有此功能或内置的此常数，但是通常这是一个好习惯。

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

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

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

但是，如果需要更高或定制的精度，则

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

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

您是否正在处理将float用于名为sectionID和currentSectionID的东西的外包代码？只是好奇。

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

如其他答案所述，双打可能会有小的偏差。您可以编写自己的方法来使用“可接受的”偏差来比较它们。但是...

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

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

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

我可以说一行答案，您应该使用：

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

为了使您了解有关正确使用相关运算符的更多信息，我在这里详细说明一些情况：通常，有3种方法来测试Java中的字符串。您可以使用== 、. equals（）或Objects.equals（）。

它们有何不同？==测试字符串中的参考质量，意味着找出两个对象是否相同。另一方面，.equals（）在逻辑上测试两个字符串是否相等。最后，Objects.equals（）测试两个字符串中的任何null，然后确定是否调用.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（）都是更通用的运算符，因此经验丰富的Web开发人员会选择它。

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

正确的方法是

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

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