Simple division en Java - est-ce un bug ou une fonctionnalité?

Je vais essayer ce simple calcul dans une application Java:

System.out.println("b=" + (1 - 7 / 10));

Évidemment, je m'attends à la sortie de la b=0.3, mais j'ai vraiment b=1 à la place.

Quoi?! Pourquoi est-ce arrivé?

Si j'écris:

System.out.println("b=" + (1 - 0.7));

- Je obtenir le bon résultat, qui est b=0.3.

Ce qui ne va pas ici?

Désolé pour mon score négatif mais c'est une question de base qu'il me fait suspice que sa part d'un accord pour améliorer quelqu'un classement dans Stackoverlow par répondre. Désolée si je suis mal.

InformationsquelleAutor msr | 2010-05-26

division java

61

Vous utilisez division entière.

Essayer 7.0/10 à la place.
- Je vais ajouter que ce n'est pas un bug. C'est une fonctionnalité. :]
- Si vous travaillez avec des variables, vous pouvez juste lancer l'un d'eux à flotteur. a = 1; b = 2; a / b = 0; (float)a / b = 0.5; a / (float)b = 0,5;
InformationsquelleAutor Xavier Ho
24

Vous avez utilisé des entiers dans l'expression 7/10, et entier 7 divisé par le nombre entier 10 est égal à zéro.

Ce que vous attendez de la flotte de point de division. Tout de la suite d'évaluer la façon dont vous attend:
```
7.0 / 10
7 / 10.0
7.0 / 10.0
7 / (double) 10
```
InformationsquelleAutor JustJeff
9

S'il vous plaît ne prenez pas cela comme une réponse à la question. Il n'est pas, mais un conseil relative à l'exploitation de la différence de int et float. J'aurais mis cela en vertu d'un commentaire, sauf que la zone réponse me permet de formater ce commentaire.

Cette caractéristique a été utilisée dans chaque respectable langage de programmation, depuis les jours de fortran (ou plus tôt) - je dois avouer que j'ai été une fois un Fortran et Cobol coup de poing de la carte du programmeur.

Comme un exemple, la division entière de 10/3 rendements valeur entière 3 depuis un entier n'a pas d'installations pour la réalisation de fractions résiduelles .3333.. .

Un des moyens que nous (les vieux temps anciens programmeurs) a été l'utilisation de cette fonctionnalité est de la boucle de contrôle.

Disons que nous voulons imprimer un tableau de 1000 chaînes, mais nous voulons insérer un saut de ligne après chaque 15 de la chaîne, d'insérer quelques prettyfying caractères à la fin de la ligne et au début de la ligne suivante. Nous exploitons cette, étant donné que l'entier k est la position d'une chaîne dans ce tableau.
```
int(k/15)*15 == k
```
est vrai que si k est divisible par 15, un événement qui se produit à une fréquence de tous les 15e de la cellule. Qui est semblable à ce que mon ami a dit à propos de son grand-père est mort montre exacte deux fois par jour.
```
int(1/15) = 0 -> int(1/15)*15 = 0
int(2/15) = 0 -> int(2/15)*15 = 0
...
int(14/15) = 0 -> int(14/15)*15 = 0
int(15/15) = 1 -> int(15/15)*15 = 15

int(16/15) = 1 -> int(16/15)*15 = 15
int(17/15) = 1 -> int(17/15)*15 = 15
...
int(29/15) = 1 -> int(29/15)*15 = 15
int(30/15) = 2 -> int(30/15)*15 = 30
```
Par conséquent, la boucle,
```
leftPrettyfy();
for(int k=0; k<sa.length; k++){
  print(sa[k]);
  int z = k + 1;
  if ((z/15)*15 == z){
    rightPrettyfy();
    leftPrettyfy();
  }
}
```
Par la variation de k en une touche de fantaisie façon dans la boucle, nous avons pu imprimer une triangulaire impression
```
1
2  3
4  5  6
7  8  9  10
11 12 13 14 15
```
Qui est de démontrer que, si vous considérez que c'est un bug, ce "bug" est une fonctionnalité utile que nous ne voulons pas être supprimé à partir de différentes langues que nous avons utilisées jusqu'à présent.
- Depuis mod (a,x) = - (x * int(a/x)), je pense que la réponse réside dans le fait qu'outre la charge de la construction d'un argument de la pile à plusieurs reprises en plus d'un code jmp pour appeler un modulo sous-routine, vous pouvez compter que le inline a == (x * int(a/x)) est une opération plus efficace qu'un - (x * int(a/x)) == 0.
- J'ai écrit "Par la variation de k en une touche de fantaisie façon dans la boucle, nous avons pu imprimer une triangulaire impression", pour k==(k/L)*L. Il doit avoir été "Par la variation de L en une touche de fantaisie façon dans la boucle, nous avons pu imprimer une triangulaire impression."
- FWIW, je l'ai testé sur ma boîte (de mi-2011 à 2,8 GHz i7 de bureau Linux en cours d'exécution JDK 1.6.0_38), et pour a = 1 .. 500 millions de dollars, sur 10 répétitions, (a % 15 == 0) est en moyenne d'environ 1500ms, vs sur 1400ms pour (a == 15 * (a / 15)). Donc, à moins que et jusqu'à ce que vous avez prouvé que % est votre point chaud, sur le matériel moderne, je pense que vous feriez mieux d'écrire ce que tu veux dire.
- "à moins que et jusqu'à ce que"?? On devrait interdire la VB, javascript, perl et la programmation.
InformationsquelleAutor Blessed Geek
1

Je trouve lettre identifiants pour être plus lisible et plus indicative de analysée type:
```
1 - 7f / 10
1 - 7 / 10f
```
ou:
```
1 - 7d / 10
1 - 7 / 10d
```
InformationsquelleAutor Fred Haslam
0

Dans mon cas, j'ai fait ça:
```
double a = (double) (MAX_BANDWIDTH_SHARED_MB/(qCount+1));
```
Au lieu de le "corriger" :
```
double a = (double)MAX_BANDWIDTH_SHARED_MB/(qCount+1);
```
Faire attention avec les parenthèses !

InformationsquelleAutor Felipe Volpato

Vous devez vous connecter pour publier un commentaire.