为什么不能直接用 比较 float？

float 在 Java 中是按照 IEEE 754 标准实现的单精度浮点数,它的存储结构决定了它存在几个关键特性：

1. 精度有限：float 只有 32 位，无法精确表示所有十进制小数。1 在二进制中是一个无限循环小数,存储时会被近似。
2. 特殊值存在：float 包含一些特殊的值，如 NaN（Not a Number，非数字）、Positive Infinity（正无穷大）和 Negative Infinity（负无穷大）。

由于这些特性，直接使用 来判断两个 float 是否“相等”是非常危险的。

直接比较 (, >, <) 的陷阱

精度误差导致“假”不相等

这是最常见的问题，由于浮点数的二进制表示和十进制表示之间的差异，两个在数学上相等的数,在计算机中可能因为微小的精度误差而被判定为不相等。

示例代码：

public class FloatComparison {
    public static void main(String[] args) {
        float a = 1.0f;
        float b = 0.9f;
        float c = 0.1f;
        // 数学上: a - (b + c) = 1.0 - (0.9 + 0.1) = 0.0
        // 但在计算机中，由于精度问题，结果可能不是0
        float result = a - (b + c);
        System.out.println("a - (b + c) 的计算结果: " + result);
        // 直接使用 == 比较，结果很可能是 false
        System.out.println("result == 0.0f ? " + (result == 0.0f)); // 输出 false 或 true，但不可靠
        // 直接使用 > 比较
        System.out.println("result > 0 ? " + (result > 0)); // 可能输出 true
        System.out.println("result < 0 ? " + (result < 0)); // 可能输出 false
    }
}

输出可能如下：

a - (b + c) 的计算结果: 5.9604645E-8
result == 0.0f ? false
result > 0 ? true
result < 0 ? false

在这个例子中，0 - 0.9 - 0.1 的理论结果是 0，但由于浮点数计算的精度损失，实际结果是一个极小的正数 9604645E-8。result == 0.0f 返回 false，而 result > 0 返回 true。

NaN 的比较

NaN 用于表示一个“不是数字”的值，0 / 0.0 或 Math.sqrt(-1.0) 的结果，根据 IEEE 754 标准，任何与 NaN 进行比较（包括 和 ）的结果都是 false。

示例代码：

public class FloatNaNComparison {
    public static void main(String[] args) {
        float nan = Float.NaN;
        // 所有比较都返回 false
        System.out.println("nan == 0.0f ? " + (nan == 0.0f)); // false
        System.out.println("nan == Float.NaN ? " + (nan == Float.NaN)); // false
        System.out.println("nan != Float.NaN ? " + (nan != Float.NaN)); // true (这是唯一能判断NaN的方式)
    }
}

这使得 完全无法用来判断一个 float 是否是 NaN。

正确的比较方法

使用误差范围（Epsilon）进行比较

这是处理精度误差最常用、最推荐的方法，我们不判断两个数是否“完全相等”，而是判断它们的“差值”是否在一个可以接受的微小误差（称为 Epsilon, ε）范围内。

核心思想： |a - b| < ε，我们就认为 a 和 b 是相等的。

示例代码：

public class FloatComparisonWithEpsilon {
    // 定义一个足够小的误差范围
    private static final float EPSILON = 1e-6f;
    public static boolean areEqual(float a, float b) {
        // 处理特殊情况：如果其中一个或两个是NaN，返回false
        if (Float.isNaN(a) || Float.isNaN(b)) {
            return false;
        }
        // 处理无穷大
        if (a == Float.POSITIVE_INFINITY && b == Float.POSITIVE_INFINITY) {
            return true;
        }
        if (a == Float.NEGATIVE_INFINITY && b == Float.NEGATIVE_INFINITY) {
            return true;
        }
        // 比较绝对差值
        return Math.abs(a - b) < EPSILON;
    }
    public static void main(String[] args) {
        float x = 0.1f + 0.2f; // 理论上是 0.3
        float y = 0.3f;
        System.out.println("x = " + x); // 输出 0.30000004
        System.out.println("y = " + y); // 输出 0.3
        // 错误的比较
        System.out.println("x == y ? " + (x == y)); // false
        // 正确的比较
        System.out.println("areEqual(x, y) ? " + areEqual(x, y)); // true
    }
}

如何选择 EPSILON？ EPSILON 的值取决于你的应用场景和所需的精度，对于大多数金融、科学计算场景，1e-6 (0.000001) 或 1e-9 是一个不错的选择，关键在于，这个值必须足够小，以至于在你的业务逻辑中,差值小于这个数的两个数可以被视作相等。

使用 java.lang.Math 或 java.lang.Float 的工具方法

Java 标准库提供了一些专门的方法来处理这些特殊情况。

a) 检查是否为 NaN

不要用 a == Float.NaN，而要使用 Float.isNaN(a)。

float value = Float.parseFloat("not a number");
if (Float.isNaN(value)) {
    System.out.println("这个值是 NaN");
}

b) 比较是否相等（包含 NaN 和无穷大）

Float.compare(float f1, float f2) 是一个非常好的工具方法，它会按照 IEEE 754 的标准进行比较,并返回一个整数值：

• 0 f1 和 f2 相等（包括都是 NaN 的情况）。
• 一个小于 0 的整数 f1 小于 f2。
• 一个大于 0 的整数 f1 大于 f2。

注意： Float.compare(a, b) == 0 会认为两个 NaN 是相等的，这与 的行为不同，如果你的业务逻辑中需要区分 NaN,那么这个方法可能不适合。

示例代码：

public class FloatCompareMethod {
    public static void main(String[] args) {
        float a = 1.0f;
        float b = 1.0f;
        float c = Float.NaN;
        float d = Float.NaN;
        float inf = Float.POSITIVE_INFINITY;
        System.out.println("Float.compare(1.0f, 1.0f) == 0: " + (Float.compare(a, b) == 0)); // true
        System.out.println("Float.compare(1.0f, 1.000001f) == 0: " + (Float.compare(a, b + 1e-6f) == 0)); // false
        // Float.compare 认为两个NaN是相等的
        System.out.println("Float.compare(Float.NaN, Float.NaN) == 0: " + (Float.compare(c, d) == 0)); // true
        // 比较无穷大
        System.out.println("Float.compare(Float.POSITIVE_INFINITY, 1.0f) > 0: " + (Float.compare(inf, a) > 0)); // true
    }
}

c) 比较大小（>, <）

对于简单的“大于”或“小于”比较，直接使用 > 和 < 运算符是安全的，只要你不把它们用在 NaN 上即可。

• NaN > 任何数 的结果是 false。
• NaN < 任何数 的结果是 false。
• Infinity > 任何有限数 的结果是 true。
• -Infinity < 任何有限数 的结果是 true。

示例代码：

public class FloatComparisonOperators {
    public static void main(String[] args) {
        float a = 10.5f;
        float b = 20.1f;
        float nan = Float.NaN;
        float inf = Float.POSITIVE_INFINITY;
        // 安全的比较
        System.out.println("a < b: " + (a < b)); // true
        // 与NaN比较总是false
        System.out.println("a > nan: " + (a > nan)); // false
        System.out.println("a < nan: " + (a < nan)); // false
        // 与无穷大比较
        System.out.println("inf > a: " + (inf > a)); // true
        System.out.println("a > inf: " + (a > inf)); // false
    }
}

总结与最佳实践

核心建议：

1. 永远不要使用 float1 == float2 来判断浮点数是否相等。
2. 永远不要使用 float1 == Float.NaN 来判断是否为 NaN。
3. 对于“相等”判断，首选误差范围法，因为它最能反映现实世界的需求（“足够接近就算相等”）。
4. 对于“大小”判断，可以直接使用 > 和 <，但要确保你的代码逻辑能正确处理 NaN 的情况（通过 Float.isNaN() 提前过滤掉）。