+0 e -0 mostram um comportamento diferente para dados int e float

Eu li este post com zero negativo e positivo .

Para meu entendimento, o código a seguir deve dar true e true como saída.

No entanto, está dando falsee truecomo saída.

Estou comparando zero negativo com um zero positivo.

public class Test {
     public static void main(String[] args) {
            float f = 0;
            float f2 = -f;
            Float F = new Float(f);
            Float F1 = new Float(f2);
            System.out.println(F1.equals(F));

            int i = 0;
            int i2 = -i;
            Integer I = new Integer(i);
            Integer I1 = new Integer(i2);
            System.out.println(I1.equals(I));
      }
  }

Por que temos um comportamento diferente para zeros para Integere Float?

Ints e floats são bestas bem diferentes em Java. Ints são codificados como complemento de dois , que possui um único valor 0. Os flutuadores usam IEEE 754 (a variante de 32 bits para flutuadores e 64 bits para duplos). O IEEE 754 é um pouco complexo, mas, para o propósito desta resposta, você só precisa saber que ele possui três seções, a primeira das quais é um sinal. Isso significa que para qualquer flutuação, há uma variante positiva e negativa¹. Isso inclui 0, então os flutuadores realmente têm dois valores "zero", +0 e -0.

Como um aparte, o complemento dos dois que os ints usam não é a única maneira de codificar números inteiros na ciência da computação. Existem outros métodos, como o complemento de alguns , mas eles têm peculiaridades - como ter ambos os valores +0 e -0 como valores distintos. ;-)

Quando você compara primitivas flutuantes (e duplas), Java trata +0 e -0 como iguais. Mas quando você caixa-los, Java trata-los separadamente, como descrito em Float#equals. Isso permite que o método equals seja consistente com sua hashCodeimplementação (e também compareTo), que apenas usa os bits do float (incluindo esse valor assinado) e os coloca como estão em um int.

Eles poderiam ter escolhido outra opção para equals / hashCode / compareTo, mas não o fizeram. Não sei ao certo quais eram as considerações de design. Mas, pelo menos em um aspecto, Float#equalssempre divergiria dos primitivos do float ==: nos primitivos NaN != NaN, mas para todos os objetos, o.equals(o)também deve ser verdade . Isso significa que se você tivesse Float f = Float.NaN, f.equals(f)mesmo assim f.floatValue() != f.floatValue().

Values ​​Os valores de NaN (não um número) têm um bit de sinal, mas não têm outro significado além de para pedidos e o Java os ignora (mesmo para pedidos).

Este é um dos exceção de flutuação igual

existem duas exceções:

Se f1 representa + 0,0f enquanto f2 representa -0,0f , ou vice-versa, o teste igual tem o valor false

O porquê também é descrito:

Essa definição permite que as tabelas de hash funcionem corretamente.

-0 e 0 serão representados de maneira diferente usando o bit 31 do Float:

O bit 31 (o bit selecionado pela máscara 0x80000000) representa o sinal do número de ponto flutuante.

Este não é o caso em Integer

Para os números inteiros, não há distinção entre -0 e 0 para números inteiros porque ele usa a representação de complemento de dois . Portanto, o seu exemplo inteiro ie i1são exatamente os mesmos.

Para os carros alegóricos, existe uma representação -0 e seu valor é equivalente a 0, mas a representação de bit é diferente. Portanto, o novo Float (0f) e o novo Float (-0f) teriam representações diferentes.

Você pode ver a diferença nas representações de bits.

System.out.println(Float.floatToIntBits(-0f) + ", " + Float.floatToIntBits(0f));

-2147483648, 0

E se você deixar fde declarar o -0f, ele será tratado como um número inteiro e você não verá nenhuma diferença na saída.