Télécharger l'article Télécharger l'article

En langage Java, il est trois façons de diviser avec des nombres décimaux, que ce soit en opérandes ou en résultats. Ainsi, il est possible de diviser 2 entiers non divisibles et d’obtenir un résultat précis avec une virgule, tout comme il est possible de diviser 2 nombres décimaux entre eux, un entier et un nombre décimal ou l’inverse. Maintenant, si vous avez besoin de travailler avec de grands nombres ou d’avoir un résultat très précis, il faut utiliser la classe BigDecimal basée sur des virgules fixes.

1

Diviser précisément deux entiers

Télécharger l'article
  1. En effet, avec Java, et ce n’est pas typique de ce seul langage !, la division de 2 entiers ( ) renvoie par défaut la seule partie entière du résultat. Si, en divisant deux entiers non divisibles vous voulez un résultat avec décimales, vous devez opérer une conversion explicite, à savoir attribuer, dans l’opération, à une des 2 valeurs le type double [1] . Dans le code qui suit, c’est a qui se voit affecter le type double  :
     int 
     a 
     = 
     55 
     ; 
     int 
     b 
     = 
     25 
     ; 
     double 
     r 
     = 
     ( 
     double 
     ) 
     a 
     / 
     b 
     // la réponse est 2.2 
    
    Publicité
2

Diviser précisément deux nombres décimaux

Télécharger l'article
  1. Pour diviser 2 valeurs décimales, utilisez la division double  [2] . De la même façon, si l’une des deux valeurs est un entier (non décimal donc !) et si l’autre est de type double, alors le résultat est une valeur décimale. Le code ci-dessous illustre bien cette division de deux nombres décimaux :
     double 
     x 
     = 
     10.5 
     ; 
     double 
     y 
     = 
     2.5 
     ; 
     x 
     / 
     y 
     // la réponse est 4.2 
    
3

Diviser avec précision avec la classe BigDecimal

Télécharger l'article
  1. Avec double , les calculs se font avec une virgule flottante double précision, ce qui, malgré l’appellation, est finalement peu précis, car les valeurs étant stockées en 64 bits sont certes intéressantes, mais sont quand même la plupart du temps arrondies. Pour des calculs précis, il faut des valeurs à virgule fixe  [3] , et c’est là qu’intervient la classe Java BigDecimal . Vous trouverez ci-dessous une même division utilisant la classe BigDecimal avec des arrondis différents :
     BigDecimal 
     bdec 
     = 
     new 
     BigDecimal 
     ( 
     "706" 
     ); 
     BigDecimal 
     bdecRes 
     = 
     bdec 
     . 
     divide 
     ( 
     new 
     BigDecimal 
     ( 
     "20" 
     )); 
     System 
     . 
     out 
     . 
     println 
     ( 
     "Résultat : " 
     + 
     bdecRes 
     ); 
     // Division avec MathContext 
     MathContext 
     mc 
     = 
     new 
     MathContext 
     ( 
     2 
     , 
     RoundingMode 
     . 
     FLOOR 
     ); 
     BigDecimal 
     bdecMath 
     = 
     bdec 
     . 
     divide 
     ( 
     new 
     BigDecimal 
     ( 
     "20" 
     ), 
     mc 
     ); 
     System 
     . 
     out 
     . 
     println 
     ( 
     "Résultat avec MathContext : " 
     + 
     bdecMath 
     ); 
     // le premier résultat sera 45,25, le second 45. 
    
    • L'énumération RoundingMode permet de préciser les différents types d'arrondis utilisés par BigDecimal. Les arrondis sont les suivants : UP (arrondit en s'éloignant de 0), DOWN (arrondit toujours vers 0), CEILING (arrondit toujours vers ), FLOOR (arrondit toujours vers ), HALF_UP (arrondit vers le plus proche voisin ou en s'éloignant de 0 en cas d’égalité des distances vers les voisins), HALF_DOWN (arrondit vers le plus proche voisin ou vers le 0 en cas d’égalité des distances vers les voisins), HALF_EVEN (arrondit vers le plus proche voisin ou vers le voisin pair si égalité des distances vers les voisins) et enfin, UNNECESSARY (les opérations doivent donner un résultat exact  [4] ).
    Publicité

À propos de ce wikiHow

Cette page a été consultée 1 597 fois.

Cet article vous a-t-il été utile ?

Publicité