错误的方法：直接使用比较运算符（不推荐）

对于初学者来说，最直观的想法就是直接使用 、>、< 等。

double a = 0.1 + 0.2; // 预期是 0.3，但实际结果可能不是
double b = 0.3;
// 错误的比较方式！
if (a == b) {
    System.out.println("a 等于 b"); // 这行代码很可能不会被执行
} else {
    System.out.println("a 不等于 b"); // 这行代码很可能会被执行
}
// 同样，比较大小也可能因精度问题而不可靠
if (a > b) {
    // ...
}

为什么不推荐？ 1 + 0.2 在计算机中的计算结果并不是精确的 3，而是一个非常接近 3 的数（30000000000000004）。a == b 的判断会返回 false，导致逻辑错误，所有基于此的 >、<、>=、<= 比较都可能因为微小的精度偏差而产生意外结果。

正确的方法：使用误差范围（Epsilon）进行比较

这是最常用且最灵活的方法，其核心思想是：我们不要求两个浮点数完全相等，而是只要它们的差距在一个非常小的、可接受的误差范围（Epsilon）内，就认为它们是相等的。

对于比较大小,可以转化为比较它们的差值。

比较是否相等 (equals)

public static boolean isEqual(double a, double b) {
    // 定义一个很小的误差范围
    double epsilon = 1e-10; // 0.0000000001
    // 如果两个数的差的绝对值小于 epsilon，则认为它们相等
    return Math.abs(a - b) < epsilon;
}
public static void main(String[] args) {
    double a = 0.1 + 0.2;
    double b = 0.3;
    System.out.println("a 和 b 是否相等? " + isEqual(a, b)); // 输出 true
    double c = 1.23;
    double d = 1.2300000001;
    System.out.println("c 和 d 是否相等? " + isEqual(c, d)); // 输出 true
    double e = 1.23;
    double f = 1.24;
    System.out.println("e 和 f 是否相等? " + isEqual(e, f)); // 输出 false
}

优点：

• 直观,易于理解。
• 可以灵活地调整 epsilon 的值来适应不同的精度需求。

缺点：

• epsilon 的选择需要根据具体应用场景来定，没有“万能”的值，对于极大或极小的数，这个固定的 epsilon 可能不适用。
• 对于比较大小,需要额外编写逻辑。

比较大小 (greaterThan, lessThan)

基于误差范围,我们可以实现安全的大小比较。

public static boolean isGreaterThan(double a, double b) {
    // a 比 b 大，并且它们的差值大于误差范围，则 a > b
    return a - b > 1e-10;
}
public static boolean isLessThan(double a, double b) {
    // a 比 b 小，并且它们的差值大于误差范围，则 a < b
    return b - a > 1e-10;
}
public static void main(String[] args) {
    double a = 0.30000000000000004; // 0.1 + 0.2
    double b = 0.3;
    System.out.println("a > b? " + isGreaterThan(a, b)); // 输出 false
    System.out.println("a < b? " + isLessThan(a, b));   // 输出 false
    System.out.println("a 约等于 b?"); // 这是正确的结论
    double c = 1.0000000001;
    double d = 1.0;
    System.out.println("c > d? " + isGreaterThan(c, d)); // 输出 true
}

推荐的方法：使用 Double.compare()

Java 标准库提供了一个专门用于比较 double 的静态方法 Double.compare()，这是最官方、最推荐的比较方法，因为它考虑了所有边界情况，包括 NaN (Not a Number)。

Double.compare(double d1, double d2) 的返回值规则如下：

• d1 等于 d2，返回 0。
• d1 小于 d2，返回 -1。
• d1 大于 d2，返回 1。

注意： Double.compare() 内部也使用了误差范围的概念来处理精度问题，但它是由语言专家实现的，比我们自己写一个 epsilon 更可靠。

使用 Double.compare() 比较大小

public static void main(String[] args) {
    double a = 0.1 + 0.2;
    double b = 0.3;
    int result = Double.compare(a, b);
    if (result == 0) {
        System.out.println("a 等于 b");
    } else if (result < 0) {
        System.out.println("a 小于 b");
    } else { // result > 0
        System.out.println("a 大于 b");
    }
    // 处理 NaN 的例子
    double nanValue = Double.NaN;
    double normalValue = 1.0;
    // 任何数与 NaN 比较都返回 false
    System.out.println("Double.compare(nanValue, normalValue) = " + Double.compare(nanValue, normalValue)); // 输出 1
    System.out.println("Double.compare(normalValue, nanValue) = " + Double.compare(normalValue, nanValue)); // 输出 -1
    // 检查一个数是否为 NaN 的正确方式
    if (Double.isNaN(nanValue)) {
        System.out.println("nanValue 是一个 NaN");
    }
}

优点：

• 官方标准，由 Java 语言规范保证，处理了所有边界情况（特别是 NaN）。
• 代码简洁,一行代码即可完成比较。
• 性能可能更好，因为它是本地方法（native method），通常由 JVM 优化。

缺点：

• 对于判断“是否相等”，需要 result == 0，不如自定义的 isEqual 方法那样语义清晰，但对于比较大小,它是最完美的选择。

特殊情况：业务允许使用 BigDecimal

如果你的计算场景对精度要求极高，例如金融、货币计算，那么最好的选择是使用 java.math.BigDecimal 类型。BigDecimal 可以表示任意精度的十进制数，避免了 double 的精度问题。

import java.math.BigDecimal;
public class BigDecimalComparison {
    public static void main(String[] args) {
        // 使用 String 构造 BigDecimal，避免 double 的精度问题
        BigDecimal a = new BigDecimal("0.1");
        BigDecimal b = new BigDecimal("0.2");
        BigDecimal sum = a.add(b); // 0.3
        BigDecimal c = new BigDecimal("0.3");
        // BigDecimal 的 equals() 方法会比较值和精度
        // 0.3 和 0.30 (精度不同) 会被认为不相等
        System.out.println("sum.equals(c)? " + sum.equals(c)); // 输出 true
        // 如果只想比较值是否相等，使用 compareTo()
        // compareTo() 只比较数值大小
        // 返回 0 表示相等，-1 表示小于，1 表示大于
        System.out.println("sum.compareTo(c)? " + sum.compareTo(c)); // 输出 0
        // 比较大小
        BigDecimal d = new BigDecimal("100.5");
        BigDecimal e = new BigDecimal("100.4");
        System.out.println("d.compareTo(e) > 0? " + (d.compareTo(e) > 0)); // 输出 true
    }
}

优点：

• 绝对精确，没有精度丢失，适合金融、科学计算等高精度场景。

缺点：

• 性能较差，相比 double 运算慢很多。
• 使用更复杂，需要通过 add(), subtract(), multiply() 等方法进行运算，不能直接使用 , , , 。
• 构造时要小心，最好用 String 构造，避免用 double 构造（因为传入的 double 本身就有精度问题）。

总结与最佳实践

核心建议：

1. 永远不要使用 a == b 来比较两个 double 是否相等。
2. 需要比较大小（大于、小于）时，首选 Double.compare()。 它是最安全、最标准的方式。
3. 如果业务逻辑上需要判断“是否近似相等”，可以自定义一个基于 epsilon 的 isEqual 方法。
4. 如果涉及金钱或任何不能容忍精度损失的计算，从一开始就使用 BigDecimal。