Por que Double.NaN == Double.NaN retorna false?

Eu estava apenas estudando questões da OCPJP e encontrei esse código estranho:

public static void main(String a[]) {
    System.out.println(Double.NaN==Double.NaN);
    System.out.println(Double.NaN!=Double.NaN);
}

Quando executei o código, obtive:

false
true

Como está o resultado falsequando comparamos duas coisas que parecem iguais? O que NaNsignifica isso ?

NaN significa "Não é um número".

A terceira edição da Java Language Specification (JLS) diz :

Uma operação que transborda produz um infinito assinado, uma operação que transborda produz um valor desnormalizado ou um zero assinado e uma operação que não possui resultado matematicamente definido produz NaN. Todas as operações numéricas com NaN como um operando produzem NaN como resultado. Como já foi descrito, o NaN não é ordenado; portanto, uma operação de comparação numérica envolvendo um ou dois retornos de NaNs falsee qualquer !=comparação envolvendo retornos de NaN true, incluindo x!=xquando xé NaN.

NaN, por definição, não é igual a qualquer número, incluindo NaN. Isso faz parte do padrão IEEE 754 e implementado pela CPU / FPU. Não é algo que a JVM precise adicionar lógica para suportar.

http://en.wikipedia.org/wiki/NaN

Uma comparação com um NaN sempre retorna um resultado não ordenado, mesmo quando comparado a si mesmo. ... Os predicados de igualdade e desigualdade são sem sinalização, portanto x = x retornando false pode ser usado para testar se x é um NaN silencioso.

Java trata todo NaN como NaN silencioso.

Por que essa lógica

NaNmeios Not a Number. O que não é um número? Qualquer coisa. Você pode ter qualquer coisa de um lado e qualquer coisa do outro lado; portanto, nada garante que ambos sejam iguais. NaNé calculado com Double.longBitsToDouble(0x7ff8000000000000L)e como você pode ver na documentação de longBitsToDouble:

Se o argumento for qualquer valor no intervalo 0x7ff0000000000001Latravés 0x7fffffffffffffffLou no intervalo 0xfff0000000000001Latravés 0xffffffffffffffffL, o resultado é um NaN.

Além disso, NaNé tratado logicamente dentro da API.

Documentação

/** 
 * A constant holding a Not-a-Number (NaN) value of type
 * {@code double}. It is equivalent to the value returned by
 * {@code Double.longBitsToDouble(0x7ff8000000000000L)}.
 */
public static final double NaN = 0.0d / 0.0;

A propósito, NaN é testado como seu exemplo de código:

/**
 * 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 value of the argument is NaN;
 *          {@code false} otherwise.
 */
static public boolean isNaN(double v) {
    return (v != v);
}

Solução

O que você pode fazer é usar compare/ compareTo:

Double.NaNé considerado por esse método igual a si mesmo e maior que todos os outros doublevalores (inclusive Double.POSITIVE_INFINITY).

Double.compare(Double.NaN, Double.NaN);
Double.NaN.compareTo(Double.NaN);

Ou equals:

Se thise argumentambos representam Double.NaN, o equalsmétodo retorna true, mesmo que Double.NaN==Double.NaNtenha o valor false.

Double.NaN.equals(Double.NaN);

Pode não ser uma resposta direta à pergunta. Mas se você quiser verificar se algo é igual a Double.NaNvocê, use este:

double d = Double.NaN
Double.isNaN(d);

Isso retornará true

O javadoc para Double.NaN diz tudo:

Uma constante contendo um valor Não-um-Número (NaN) do tipo double. É equivalente ao valor retornado por Double.longBitsToDouble(0x7ff8000000000000L).

Curiosamente, a fonte para Doubledefine NaNassim:

public static final double NaN = 0.0d / 0.0;

O comportamento especial que você descreve é ​​conectado à JVM.

conforme o padrão IEEE para aritmética de ponto flutuante para números de precisão dupla,

A representação padrão de ponto flutuante de precisão dupla IEEE requer uma palavra de 64 bits, que pode ser representada como numerada de 0 a 63, da esquerda para a direita

Onde,

S: Sign – 1 bit
E: Exponent – 11 bits
F: Fraction – 52 bits 

Se E=2047(todos Esão 1) e Ffor diferente de zero, então V=NaN("Não é um número")

Que significa,

Se todos os Ebits forem 1 e se houver um bit diferente de zero F, o número será NaN.

portanto, entre outros, todos os números a seguir são NaN,

0 11111111 0000000000000000010000000000000000000000000000000000 = NaN
1 11111111 0000010000000000010001000000000000001000000000000000 = NaN
1 11111111 0000010000011000010001000000000000001000000000000000 = NaN

Em particular, você não pode testar

if (x == Double.NaN) 

para verificar se um resultado específico é igual Double.NaN, porque todos os valores "não são números" são considerados distintos. No entanto, você pode usar o Double.isNaNmétodo:

if (Double.isNaN(x)) // check whether x is "not a number"

NaN é um valor especial que indica "não é um número"; é o resultado de certas operações aritméticas inválidas, como sqrt(-1), e possui a propriedade (às vezes irritante) disso NaN != NaN.

Nenhum número representa o resultado de operações cujo resultado não é representável com um número. A operação mais famosa é 0/0, cujo resultado não é conhecido.

Por esse motivo, NaN não é igual a nada (incluindo outros valores que não são um número). Para mais informações, basta verificar a página da wikipedia: http://en.wikipedia.org/wiki/NaN

De acordo com este link , possui várias situações e difíceis de lembrar. É assim que eu me lembro e os distingo. NaNsignifica "matematicamente indefinido", por exemplo: "o resultado de 0 dividido por 0 é indefinido" e, como é indefinido, portanto "a comparação relacionada com o indefinido é obviamente indefinida". Além disso, funciona mais como premissas matemáticas. Por outro lado, tanto o infinito positivo quanto o negativo são predefinidos e definitivos, por exemplo "infinito positivo ou negativo grande é bem definido matematicamente".