Java双重比较与字符串比较

我遇到了一些旧的遗留代码，如下所示：

s1 = Double.toString(dbVal1);
s2 = Double.toString(dbVal2);
if (s1.compareTo(s2)!=0)
{
    return false;
}
return true;

其中

dbVal1

和

dbVal2

都是双值

我在评测时发现了这一点，

toString

方法调用占用了相当多的CPU时间。有什么原因我不能用1或2来代替这个吗？如果有，有什么区别/哪一个更好

一,

二,

---

当然，最快的方法是让

变量保持原样并进行比较。自动装箱，如果其他方法对CPU来说是不必要的负担，则使用方法。
通常，
double
值的比较方式是，它们的绝对差异在一定范围内

这是因为
double
s的内部表示方式以及可能出现的舍入误差，取决于计算值的方式

如果您能够绝对确保此类错误在您的案例中不是问题，那么直接比较它们也会很有用

在字符串域中进行比较对我来说似乎没有用。
dbVal1==dbVal2
与
字符串版本
不同，因为NaN

double a = 0.0 / 0.0;
double b = 0.0 / 0.0;
System.out.println(a == b);    // false
System.out.println(Double.toString(a).equals(Double.toString(b)));    // true

我认为编写这段代码的人希望NaN等于NaN。
类Double提供了一个
compare
方法，将NaN视为相等。我已经测试了几个有趣的案例，在每个案例中，它都给出了与更间接的字符串方法相同的结果：

public class Test {
  public static void main(String[] args) {
    testit(0.0,0.0);
    testit(0.0, -0.0);
    testit(Double.NaN, Double.NaN);
    testit(Double.NaN, 3.0);
    testit(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    testit(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
  }

  private static void testit(double a, double b) {
    boolean doubleEquals = (a == b);
    boolean doubleCompare = Double.compare(a, b) == 0;
    boolean stringCompare = Double.toString(a).compareTo(Double.toString(b)) == 0;
    if(doubleCompare != stringCompare){
      System.out.print("* ");
    }
    System.out.println("a=" + a + " b=" + b + " double == " + doubleEquals
        + " Double compare " + doubleCompare + " String compare "
        + stringCompare);
  }
}

输出：

a=0.0 b=0.0 double == true Double compare true String compare true
a=0.0 b=-0.0 double == true Double compare false String compare false
a=NaN b=NaN double == false Double compare true String compare true
a=NaN b=3.0 double == false Double compare false String compare false
a=Infinity b=Infinity double == true Double compare true String compare true
a=-Infinity b=-Infinity double == true Double compare true String compare true

似乎你可以…有什么原因让字符串转换吗？也许，出于某种原因，他们想要对那些
double
s进行字典排序？这就是我想要删除的，这会导致很多速度减慢，但我不知道是否有必要，因为我想不出什么原因。@kooker字典顺序只与
resp相关<代码>比较（）0

。这里我们只需检查

==

resp<代码>==0，因此顺序不相关。我猜原始程序员是在试图避免舍入错误？检查这个答案：调用

static int compare（双d1，双d2）

时，我们没有自动装箱的情况…@glglglgl，如果代码中有其他内容，我们也没有解释。这只是“仅供参考”的建议。我只是在尝试测试时看到了这个案例。但是双倍。比较（双倍，双倍）似乎使这项工作。有什么理由不使用这种方法吗？@AndrewWirtz你是对的。我只展示了

a==b

与

String

版本不同。我已经相应地编辑了我的答案。我需要考虑<代码>双.COMPRACE（）/<代码>。不要忘记<代码> 0 和<代码> -0 。@ MARCO13有很多事情要考虑，<代码>无穷大< /代码>，<代码> -无穷< /COD>。我认为，

Double.compare（a，b）==0

始终与

Double.toString（a）.等于（Double.toString（b））

相同。不过，我不想在回答中肯定地断言，

+/-Infinity

不应该是一个问题。我想不出任何其他情况下的行为是不同的（并且实际尝试了一些接近

MAX_VALUE

等的边界情况）。然而，将双倍作为字符串进行比较是一个可怕的想法，无论如何，让我们希望这些边界案例与询问者无关。谢谢！我将用Double.compare替换toString比较

public class Test {
  public static void main(String[] args) {
    testit(0.0,0.0);
    testit(0.0, -0.0);
    testit(Double.NaN, Double.NaN);
    testit(Double.NaN, 3.0);
    testit(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    testit(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
  }

  private static void testit(double a, double b) {
    boolean doubleEquals = (a == b);
    boolean doubleCompare = Double.compare(a, b) == 0;
    boolean stringCompare = Double.toString(a).compareTo(Double.toString(b)) == 0;
    if(doubleCompare != stringCompare){
      System.out.print("* ");
    }
    System.out.println("a=" + a + " b=" + b + " double == " + doubleEquals
        + " Double compare " + doubleCompare + " String compare "
        + stringCompare);
  }
}

a=0.0 b=0.0 double == true Double compare true String compare true
a=0.0 b=-0.0 double == true Double compare false String compare false
a=NaN b=NaN double == false Double compare true String compare true
a=NaN b=3.0 double == false Double compare false String compare false
a=Infinity b=Infinity double == true Double compare true String compare true
a=-Infinity b=-Infinity double == true Double compare true String compare true