Java Float.isNaN Double.isNaN方法工作原理

From Java Language Specification:

Floating-point equality testing is performed in accordance with the rules of the IEEE 754 standard:

If either operand is NaN, then the result of == is false but the result of != is true. Indeed, the test x!=x is true if and only if the value of x is NaN. (The methods Float.isNaN and Double.isNaN may also be used to test whether a value is NaN.)

Positive zero and negative zero are considered equal. Therefore, -0.0==0.0 is true, for example.

Otherwise, two distinct floating-point values are considered unequal by the equality operators. In particular, there is one value representing positive infinity and one value representing negative infinity; each compares equal
only to itself, and each compares unequal to all other values.

Floating-point equality testing is performed in accordance with the rules of the IEEE 754 standard:

If either operand is NaN, then the result of == is false but the result of != is true. Indeed, the test x!=x is true if and only if the value of x is NaN. (The methods Float.isNaN and Double.isNaN may also be
used to test whether a value is NaN.)

Positive zero and negative zero are considered equal. Therefore, -0.0==0.0 is true, for example.

Otherwise, two distinct floating-point values are considered unequal by the equality operators. In particular, there is one value representing positive infinity and one value representing negative infinity; each compares equal only to itself, and each compares
unequal to all other values.

That method can return true for certain operations, for example:

System.out.println(Float.isNaN(0.0f / 0.0f));
System.out.println(Double.isNaN(Math.sqrt(-1)));

Basically, 

NaN

 represents
an undefined value. The value of 

0.0
/ 0.0

 is 

NaN

,
and 

Nan
!= NaN

. It may seem logical because 

Math.sqrt(-1)

 also
gives you 

NaN

.

See the javadoc of 

Double.NaN

:

It is equivalent to the value returned by 

Double.longBitsToDouble(0x7ff8000000000000L)

And then 

Double.longBitsToDouble()

:

If the argument is any value in the range 

0x7ff0000000000001L

 through 

0x7fffffffffffffffL

 or
in the range 

0xfff0000000000001L

 through 

0xffffffffffffffffL

,
the result is a 

NaN

.
No IEEE 754 floating-point operation provided by Java can distinguish between two NaN values of the same type with different bit patterns.

From Java Language Specification:

Floating-point equality testing is performed in accordance with the rules of the IEEE 754 standard:

If either operand is NaN, then the result of == is false but the result of != is true. Indeed, the test x!=x is true if and only if the value of x is NaN. (The methods Float.isNaN and Double.isNaN may also be used to test whether a value is NaN.)

Positive zero and negative zero are considered equal. Therefore, -0.0==0.0 is true, for example.

Otherwise, two distinct floating-point values are considered unequal by the equality operators. In particular, there is one value representing positive infinity and one value representing negative infinity; each compares equal only to itself, and each compares
unequal to all other values.