+0 et -0 montre un comportement différent pour les données int et float

J'ai lu ce post zéro négatif et positif .

À ma compréhension, le code suivant devrait donner true et true en sortie.

Cependant, il donne falseet truecomme sortie.

Je compare un zéro négatif avec un zéro positif.

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));
      }
  }

Pourquoi avons-nous un comportement différent pour les 0 pour Integeret Float?

Ints et flotteurs sont des bêtes assez différentes en Java. Les entiers sont codés comme un complément à deux , qui a une seule valeur 0. Les flotteurs utilisent IEEE 754 (la variante 32 bits pour les flottants et 64 bits pour les doubles). IEEE 754 est quelque peu complexe, mais pour les besoins de cette réponse, il vous suffit de savoir qu'il comporte trois sections, dont la première est un bit de signe. Cela signifie que pour tout flotteur, il existe une variante positive et négative¹. Cela inclut 0, donc les flottants ont en fait deux valeurs "zéro", +0 et -0.

Soit dit en passant, le complément à deux que les ints utilisent n'est pas le seul moyen de coder des entiers en informatique. Il existe d'autres méthodes, comme celles de complément , mais elles ont des bizarreries - comme avoir à la fois un +0 et -0 comme valeurs distinctes. ;-)

Lorsque vous comparez des primitives flottantes (et doubles), Java traite +0 et -0 comme égaux. Mais lorsque vous les encadrez, Java les traite séparément, comme décrit dans Float#equals. Cela permet à la méthode equals d'être cohérente avec leur hashCodeimplémentation (ainsi que compareTo), qui utilise simplement les bits du float (y compris cette valeur signée) et les pousse tels quels dans un int.

Ils auraient pu choisir une autre option pour equals / hashCode / compareTo, mais ils ne l'ont pas fait. Je ne sais pas quelles étaient les considérations de conception. Mais à au moins un égard, Float#equalsallait toujours diverger de la primitive flottante ==: dans les primitives NaN != NaN, mais pour tous les objets, cela o.equals(o)doit aussi être vrai . Cela signifie que si vous l'aviez Float f = Float.NaN, alors f.equals(f)même si f.floatValue() != f.floatValue().

¹ Les valeurs NaN (pas un nombre) ont un bit de signe, mais il n'a pas d'autre signification que pour la commande, et Java l'ignore (même pour la commande).

Ceci est l'un des Float est égal à l'exception

il y a deux exceptions:

Si f1 représente + 0,0f tandis que f2 représente -0,0f , ou vice versa, le test égal a la valeur false

Le pourquoi est également décrit:

Cette définition permet aux tables de hachage de fonctionner correctement.

-0 et 0 seront représentés différemment en utilisant le bit 31 de Float:

Le bit 31 (le bit qui est sélectionné par le masque 0x80000000) représente le signe du nombre à virgule flottante.

Ce n'est pas le cas Integer

Pour les entiers, il n'y a pas de distinction entre -0 et 0 pour les entiers car il utilise la représentation du compliment Twos . Donc, votre exemple entier iet i1sont exactement les mêmes.

Pour les flottants, il y a une représentation -0, et sa valeur est équivalente à 0, mais la représentation binaire est différente. Par conséquent, le nouveau flotteur (0f) et le nouveau flotteur (-0f) auraient des représentations différentes.

Vous pouvez voir la différence dans les représentations de bits.

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

-2147483648, 0

Et si vous laissez le fpour déclarer le, -0fil sera traité comme un entier et vous ne verrez aucune différence dans la sortie.