Math.rint() et Math.round() ont quelques différences, mais celle qui peut avoir un impact sur la logique métier d'une application Java le plus, c'est la manière dont ils gèrent l'arrondissement des nombres entiers qui sont sur la frontière (par exemple, 4.5 est à la limite de 4 et 5). Considérons l'extrait de code suivant et de sortie:
Comme vous pouvez le voir, Math.rint(4.5) fait des tours de down, tandis que Math.round(4.5) tours, et cela mérite d'être souligné. Cependant, dans tous les autres cas, ils ont tous deux présentent les mêmes règles d'arrondi qui nous attend.
Exemple des Mathématiques.rint():
2.50 se trouve entre 2,00 et 3,00.
Les mathématiques.rint() retourne le plus proche de la même valeur double.
Les mathématiques.rint(2.50) renvoie 2.0.
Exemple des Mathématiques.round():
2.50 se trouve entre 2,00 et 3,00.
Les mathématiques.round() renvoie le plus proche nombre entier.
Les mathématiques.ronde(2.50) renvoie 3
4
Différence est à .5.
Math.round() convertit [10.5, 11.5[ à 11
Math.rint() convertit ]10.5, 11.5[ à 11,0
Math.round() renvoie un long ou int.
Math.rint() retourne double.
De sorte qu'il peut être dit que Math.round() favorise la mi-point(0.5) pour une plus grande valeur.
2
Ils se comportent différemment lorsqu'il est passé quelque chose se terminant en .5signée 0, NaN, ou une Infinité.
Math.round accepte à la fois les doubles et floats, et dispose de différents types de retour pour une raison quelconque (long et int respectivement, qui sont les plus petits de type assez grand pour couvrir toute la gamme représentée par le paramètre).
Math.rint accepte doubles et renvoie doubles. Il est moins "destructeur" que Math.roundcar il ne modifie pas les valeurs sous plusieurs conditions (voir ci-dessous).
Le comportement de cette méthode suit la Norme IEEE 754, section 4. Ce type d'arrondi est parfois appelé d'arrondi au plus près, ou de l'arrondi. Il minimise les erreurs d'arrondi qui résultent de façon constante, arrondir une valeur médiane dans une seule direction.
(À partir de Jon Skeet réponse en C#. Le comportement de Mathématiques.Rond en C# est plus similaire à Java Math.rintaussi déroutant que cela puisse être.)
Renvoie le double de la valeur qui est la plus proche de la valeur de l'argument et est égale à une mathématique entier.
Renvoie le double de la valeur qui est la plus proche de la valeur de l'argument et est égale à une mathématique entier. Si les deux valeurs que sont les mathématiques entiers sont également à proximité, le résultat est la valeur de l'entier qui est même.
Cas particuliers:
Si la valeur de l'argument est déjà égale à une mathématique entier, le résultat est le même que l'argument.
Si l'argument est NaN ou un infini positif ou nul ou négatif égal à zéro, alors le résultat est le même que l'argument.
...
staticlong round(double a)
...
staticint round(float a)
Renvoie le plus proche de l'int de l'argument, en lien avec les arrondissement.
Cas particuliers:
Si l'argument est NaN, le résultat est 0.
Si l'argument est négatif de l'infini ou de toute valeur inférieure ou égale à la valeur de l'Entier.MIN_VALUE, le résultat est égal à la valeur de l'Entier.MIN_VALUE.
Si l'argument est positif de l'infini ou de toute valeur supérieure ou égale à la valeur de l'Entier.MAX_VALUE, le résultat est égal à la valeur de l'Entier.MAX_VALUE.
Vous pouvez également modifier le comportement de Math.round.
publicenumRoundingModeextendsEnum<RoundingMode>
Spécifie un arrondissement comportement pour les opérations numériques capables de vous débarrasser de précision. Chaque mode d'arrondi indique la façon dont le moins significatif retourné chiffres d'un résultat arrondi est calculée. Si le nombre de chiffres sont retournés que les chiffres nécessaires pour représenter l'exact résultat numérique, les rebuts de chiffres sera désigné comme le rebut de la fraction peu importe les chiffres de la contribution à la valeur du nombre. En d'autres termes, considéré comme une valeur numérique, la jetée fraction pourrait avoir une valeur absolue supérieure à un.
Chaque mode d'arrondi description comprend un tableau indiquant comment les différents à deux chiffres des valeurs décimales sera arrondi à un chiffre décimal de la valeur sous le mode d'arrondi en question. Le résultat de la colonne dans les tableaux qui pourrait être obtenu par la création d'un BigDecimal nombre à la valeur spécifiée, formant un MathContext objet avec les paramètres appropriés (précision à 1, et le roundingMode réglé sur le mode d'arrondi en question), et en appelant tour sur ce nombre avec le bon MathContext. Un tableau récapitulatif montrant les résultats de ces arrondissement des opérations pour tous les modes d'arrondi apparaît ci-dessous.
|Result of rounding input to one digit with the given rounding
______ı________________________________________________________________________________________
|Input| UP DOWN CEILING FLOOR HALF_UP HALF_DOWN HALF_EVEN UNNECESSARY
5.5|6565656throwArithmeticException2.5|3232322throwArithmeticException1.6|2121222throwArithmeticException1.1|2121111throwArithmeticException1.0|11111111-1.0|-1-1-1-1-1-1-1-1-1.1|-2-1-1-2-1-1-1throwArithmeticException-1.6|-2-1-1-2-2-2-2throwArithmeticException-2.5|-3-2-2-3-3-2-2throwArithmeticException-5.5|-6-5-5-6-6-5-6throwArithmeticException
2
Il y a un type de retour de la différence:
Math.round() retourne long ou int
Math.rint() retourne double
Mais la différence essentielle est dans le traitement numérique des valeurs de 0.5.
Math.round() convertit 9.5 <= x < 10.5 à 10
Math.rint() convertit 9.5 <= x <= 10.5 à 10.0
Math.round() convertit 10.5 <= x < 11.5 à 11
Math.rint() convertit 10.5 < x < 11.5 à 11.0
Math.round() convertit 11.5 <= x < 12.5 à 12
Math.rint() convertit 11.5 <= x <= 12.5 à 12.0
(Notez les inégalités!) Donc Math.round() toujours des tours jusqu'à la mi-point (0.5): la documentation.
Au lieu de cela, Math.rint() favorise le plus proche même nombre à mi-parcours: la documentation.
Par exemple, essayez d'exécuter la suite de exemple trivial:
publicclassHelloWorld{publicstaticvoid main(String[]args){System.out.println("Math.round() of 9.5 is "+Math.round(9.5));System.out.println("Math.round() of 10.5 is "+Math.round(10.5));System.out.println("Math.round() of 11.5 is "+Math.round(11.5));System.out.println("Math.round() of 12.5 is "+Math.round(12.5));System.out.println("Math.rint() of 9.5 is "+Math.rint(9.5));System.out.println("Math.rint() of 10.5 is "+Math.rint(10.5));System.out.println("Math.rint() of 11.5 is "+Math.rint(11.5));System.out.println("Math.rint() of 12.5 is "+Math.rint(12.5));}}
Noter que l'actuel haut de réponse est mal. J'ai essayé de proposer une modification à son poste, mais il a été rejeté. De sorte que par le rejet des commentaires, je suis en train de mettre mes modifications comme une nouvelle réponse.
1
Pour les Nombres positifs:
si la partie fractionnaire se trouve en 0 (inclus) et 0,5 (exclusif) puis le round() donne la partie entière du nombre.
si la partie fractionnaire se trouve dans 0,5 (inclus) et 1 (exclusif) puis le round() donne la partie entière du nombre + 1.
Mais dans le cas du rint,
si la partie fractionnaire se trouve en 0 (inclus) et 0,5 (inclus) puis rint() donne la partie entière du nombre.
si la partie fractionnaire se trouve dans 0,5 (exclusif) et 1 (exclusif) puis le round() donne la partie entière du nombre + 1.
Pour nombre négatif:
Les deux ont le même comportement, je.e
si la partie fractionnaire se trouve en 0 (inclus) et 0,5 (inclus), la partie entière du nombre est retourné.
si la partie fractionnaire se trouve dans 0,5 (inclus) et 1 (exclusif) partie entière du nombre -1.
partie fractionnaire est juste la partie de certain nombre après la virgule
0
En raison du fait que votre question a été largement répondu, je ne vais pas courir plus de l'évident, mais fournira un article utile, je suis tombé sur:
Math.rint()
etMath.round()
ont quelques différences, mais celle qui peut avoir un impact sur la logique métier d'une application Java le plus, c'est la manière dont ils gèrent l'arrondissement des nombres entiers qui sont sur la frontière (par exemple,4.5
est à la limite de4
et5
). Considérons l'extrait de code suivant et de sortie:De sortie:
Comme vous pouvez le voir,
Math.rint(4.5)
fait des tours de down, tandis queMath.round(4.5)
tours, et cela mérite d'être souligné. Cependant, dans tous les autres cas, ils ont tous deux présentent les mêmes règles d'arrondi qui nous attend.Ici est utile de Code Ranch article qui compare brièvement
Math.rint()
etMath.round()
: http://www.coderanch.com/t/239803/java-programmer-OCPJP/certification/Difference-rint-methods-Math-classExemple des Mathématiques.rint():
2.50 se trouve entre 2,00 et 3,00.
Les mathématiques.rint() retourne le plus proche de la même valeur double.
Les mathématiques.rint(2.50) renvoie 2.0.
Exemple des Mathématiques.round():
2.50 se trouve entre 2,00 et 3,00.
Les mathématiques.round() renvoie le plus proche nombre entier.
Les mathématiques.ronde(2.50) renvoie 3
Différence est à .5.
Math.round()
convertit[10.5, 11.5[
à 11Math.rint()
convertit]10.5, 11.5[
à 11,0Math.round()
renvoie un long ou int.Math.rint()
retourne double.De sorte qu'il peut être dit que
Math.round()
favorise la mi-point(0.5) pour une plus grande valeur.Ils se comportent différemment lorsqu'il est passé quelque chose se terminant en
.5
signée 0, NaN, ou une Infinité.Math.round
accepte à la fois lesdouble
s etfloat
s, et dispose de différents types de retour pour une raison quelconque (long
etint
respectivement, qui sont les plus petits de type assez grand pour couvrir toute la gamme représentée par le paramètre).Math.rint
acceptedouble
s et renvoiedouble
s. Il est moins "destructeur" queMath.round
car il ne modifie pas les valeurs sous plusieurs conditions (voir ci-dessous).(À partir de Jon Skeet réponse en C#. Le comportement de Mathématiques.Rond en C# est plus similaire à Java
Math.rint
aussi déroutant que cela puisse être.)De la docs:
...
Vous pouvez également modifier le comportement de
Math.round
.Il y a un type de retour de la différence:
Math.round()
retournelong
ouint
Math.rint()
retournedouble
Mais la différence essentielle est dans le traitement numérique des valeurs de
0.5
.Math.round()
convertit9.5 <= x < 10.5
à10
Math.rint()
convertit9.5 <= x <= 10.5
à10.0
Math.round()
convertit10.5 <= x < 11.5
à11
Math.rint()
convertit10.5 < x < 11.5
à11.0
Math.round()
convertit11.5 <= x < 12.5
à12
Math.rint()
convertit11.5 <= x <= 12.5
à12.0
(Notez les inégalités!) Donc
Math.round()
toujours des tours jusqu'à la mi-point (0.5): la documentation.Au lieu de cela,
Math.rint()
favorise le plus proche même nombre à mi-parcours: la documentation.Par exemple, essayez d'exécuter la suite de exemple trivial:
Noter que l'actuel haut de réponse est mal. J'ai essayé de proposer une modification à son poste, mais il a été rejeté. De sorte que par le rejet des commentaires, je suis en train de mettre mes modifications comme une nouvelle réponse.
Pour les Nombres positifs:
si la partie fractionnaire se trouve en 0 (inclus) et 0,5 (exclusif) puis le round() donne la partie entière du nombre.
si la partie fractionnaire se trouve dans 0,5 (inclus) et 1 (exclusif) puis le round() donne la partie entière du nombre + 1.
Mais dans le cas du rint,
si la partie fractionnaire se trouve en 0 (inclus) et 0,5 (inclus) puis rint() donne la partie entière du nombre.
si la partie fractionnaire se trouve dans 0,5 (exclusif) et 1 (exclusif) puis le round() donne la partie entière du nombre + 1.
Pour nombre négatif:
Les deux ont le même comportement, je.e
si la partie fractionnaire se trouve en 0 (inclus) et 0,5 (inclus), la partie entière du nombre est retourné.
si la partie fractionnaire se trouve dans 0,5 (inclus) et 1 (exclusif) partie entière du nombre -1.
partie fractionnaire est juste la partie de certain nombre après la virgule
En raison du fait que votre question a été largement répondu, je ne vais pas courir plus de l'évident, mais fournira un article utile, je suis tombé sur:
https://way2java.com/java-lang/class-math-java-lang/difference-of-math-rintdouble-and-math-rounddouble/
Ce que j'ai trouvé de la plus haute importance est le fait que la tour renvoie la plus proche nombre entier comme un entier ou long.