相关疑难解决方法(0)

parseFloat("NaN")

返回"NaN",但是

parseFloat("NaN") == "NaN"

返回false.现在,这确实是一件好事,它确实会返回错误,但我不明白这是怎么回事.JavaScript创建者是否只是将此作为特例？因为否则我无法理解这是如何返回false的.

我正在阅读Joshua Bloch的有效java和第8项:当覆盖等于时遵守一般合同,这个陈述是写的

对于float字段,使用Float.compare方法; 对于双字段,请使用Double.compare.浮法和双场的特殊处理是由Float.NaN,-0.0f和类似的双常数的存在所必需的;

有人可以解释我为什么我们不能==用于浮动或双重比较

我在看openjdk-1.7.0_25源代码,我看过这个方法:

/**
 * Returns {@code true} if the specified number is a
 * Not-a-Number (NaN) value, {@code false} otherwise.
 *
 * @param   v   the value to be tested.
 * @return  {@code true} if the argument is NaN;
 *          {@code false} otherwise.
 */
static public boolean isNaN(float v) {
    return (v != v);
}

当这种方法可以返回时,我无法理解它是如何工作的true？

我们正在使用Sonar检查代码的质量,Sonar找到了将float或double相等的代码与常量值进行比较,如下所示:

if (x == 0.0) { … }

变量与(0.0)相比较的值是常量,如果变量可以等于此值,则该值也不会计算,而只能通过常量设置.这通常用于检查变量是否尚未设置或仍处于初始化状态,例如-1.0,在值只能为正的情况下可能用于"尚未设置".

因此,由于这些值从未计算过,只是从常量中设置,因此声纳投诉对我们没用.仅对于计算值(或者不能精确表示为浮点数或双精度值的断裂值),关于平等测试的抱怨是有意义的.

我现在的问题是:更改代码的最佳做法是什么,以便Sonar不再抱怨这个？

我看到几个选项:

1. 将"test-for-unset"解压缩为特殊的测试函数; 但这只会减少发生次数(减少到1),而不是一般的问题.
2. 标记Sonar的代码,使用特殊的装饰器忽略它.但我们希望避免使用这样的装饰器.
3. 隐藏比较背后的比较(0.0 <= x && x <= 0.0)或!(x != 0.0)(目前似乎对Sonar没问题).
4. 调用Double.doubleToRawLongBits()比较这些值的位,如下所示:(Double.doubleToRawLongBits(x) != Double.doubleToRawLongBits(0.0)).
5. 其他想法？

我真的不喜欢这些解决方案,我想,也许,有一个更好的解决方案,我想不到.

最近我接受了一家软件公司的采访,在技术能力回合中询问了以下问题:

以这样的方式声明我,条件总是为真:

while(i != i) {
}

在Java中技术上是否可以分配这种东西？

所以我最近开始喜欢语言kotlin.今天,在比较双打时,我遇到了不可避免的事情NaN.

fun main(args: Array<String>) {
    val nan = Double.NaN
    println("1: " + (nan == nan))
    println("2: " + (nan == (nan as Number)))
    println("3: " + ((nan as Number) == nan))
}

NB :( Double 是子类型 )Number

运行上面的代码会产生:

1: false
2: true
3: true

我理解与Java 相比,我会期望所有的表达式.NaNfalsefalse

如何解释这种行为？它背后的理由是什么？

我想知道为什么undefined == undefined但是NaN != NaN.

在标准Java API中,是否存在==将返回true但equals将返回的任何方案false.理论上,这可以写入用户定义的类,而非常像这样

class A {
    public boolean equals(Object o) {
        return this != o;
    }
}

是否有在示例,其中一些对象的任何实际烤b和c,b == c将返回true,但b.equals(c)回报false？此外,有这样的行为会有任何可能的好处吗？

可能重复:
为什么Double.NaN == Double.NaN返回false？

NaN ="NaN"代表"不是数字".如果浮点运算有一些输入参数导致操作产生一些未定义的结果,则会产生"Nan".例如,0.0除以0.0是算术上未定义的.取负数的平方根也是不确定的.

我试图在Java中使用NaN Constant

public class NaNDemo {
    public static void main(String s[]) {
        double x = Double.NaN;
        double y = Double.NaN;

        System.out.println((x == y));
        System.out.println("x=" + x);
        System.out.println("y=" + y);
    }
}

产量

false
x=NaN
y=NaN

那么为什么x == y是假的？

可能重复:
为什么Double.NaN == Double.NaN返回false？

这纯粹是出于好奇.

我做了这样的事情:

public static void main(String args[]) throws Exception {
        System.out.println(Double.NaN==Double.NaN);
    }

输出是false.这不应该回归true？

为什么会这样？

我想测试Java中无穷大是否等于无穷大:

Double.POSITIVE_INFINITY == Double.POSITIVE_INFINITY

事实证明这是真实的,我对结果感到惊讶.我的问题是两个无限值如何相等？