Java signé zéro et de la boxe

Dernièrement, j'ai écrit un projet en Java et a remarqué une étrange caractéristique avec un lit double/Double mise en œuvre. Le type double en Java a deux 0, c'est à dire 0.0 et -0.0 (signé zéro). La chose étrange est que:

0.0 == -0.0

évalue à true, mais:

new Double(0.0).equals(new Double(-0.0))

évalue à false. Personne ne sait la raison derrière tout cela?

L'habituelle façon d'éviter cela est d'ajouter 0.0. Voir ici pour un peu plus de détails.

InformationsquelleAutor uhz | 2013-02-08

40

Il est expliqué dans la javadoc:
Noter que dans la plupart des cas, pour les deux instances de la classe Double, d1 et d2, la valeur de d1.est égal à(d2) est vrai si et seulement si
```
   d1.doubleValue() == d2.doubleValue() 
```
aussi a la valeur true. Il y a toutefois deux exceptions:
- Si d1 et d2 représentent tous les deux de Double.NaN, puis la méthode equals retourne vrai, même si le Double.NaN==Double.NaN a la valeur false.
- Si d1 représente +0.0 tout en d2 représente -0.0, ou vice versa, l'égalité des test a la valeur false, même si +0.0==-0.0 a la valeur true.
Cette définition permet à des tables de hachage pour fonctionner correctement.
Maintenant, vous pourriez demander pourquoi 0.0 == -0.0 est vrai. En fait, ils ne sont pas strictement identiques. Par exemple:
```
Double.doubleToRawLongBits(0.0) == Double.doubleToRawLongBits(-0.0); //false
```
est faux. Cependant, la JLS exige ("en conformité avec les règles de la norme IEEE 754 la norme") que:

Zéro positif et négatif de zéro sont considérées comme égales.

donc 0.0 == -0.0 est vrai.
- Et le JLS exige que parce que la norme IEEE 754 exige.
- En effet Ajoutée que des éclaircissements.
InformationsquelleAutor assylias
2

Qu'il est important de undertand l'utilisation de signé zéro dans la Double classe. (Charges de Java expérimenté les programmeurs ne sont pas).

La réponse courte est que (par définition) "-0.0 est inférieur 0.0" dans toutes les méthodes de la Double classe (qui est, equals(), comparer(), compareTo(), etc)

Double permet à tous les nombres à virgule flottante à être "totalement ordonnée sur un numéro de ligne".
Les Primitives de se comporter de la façon dont un utilisateur de penser à des choses (un monde réel définition) ... 0d = -0d

Les extraits suivants illustrent le comportement ...
```
final double d1 = 0d, d2 = -0d;

System.out.println(d1 == d2); //prints ... true
System.out.println(d1 < d2);  //prints ... false
System.out.println(d2 < d1);  //prints ... false
System.out.println(Double.compare(d1, d2)); //prints ... 1
System.out.println(Double.compare(d2, d1)); //prints ... -1
```
Il y a d'autres posts qui sont pertinentes et très bien expliquer le contexte ...

1: Pourquoi les nombres à virgule flottante ont signé des zéros?

2: Pourquoi Java est Double.comparer(double, double) mise en œuvre de la façon dont il est?

Et un mot de prudence ...

Si vous ne savez pas que, dans la Double classe, "-0.0 est inférieur 0.0", vous pouvez faire prendre lors de l'utilisation de méthodes comme equals() et compare() et compareTo() de Double dans la logique des tests. Par exemple, regardez ...
```
final double d3 = -0d; //try this code with d3 = 0d; for comparison

if (d3 < 0d) {     
    System.out.println("Pay 1 million pounds penalty");
} else {           
    System.out.println("Good things happen"); //this line prints
}


if (Double.compare(d3, 0d) < 0) { //use Double.compare(d3, -0d) to match the above behaviour
    System.out.println("Pay 1 million pounds penalty"); //this line prints
} else {                              
    System.out.println("Good things happen"); 
}
```
et égaux, tu pourrais essayer de ... de nouvelles Double(d3).equals(0d) || nouveau Double(d3).est égal à(-0d)

InformationsquelleAutor K John Smith
-7

En utilisant == déclaration de la comparaison de valeurs. Avec est égal à votre sont des objets de comparaison.

InformationsquelleAutor MiSu

Vous devez vous connecter pour publier un commentaire.