|
|
Publié sur 07/04/2015 14:53:05
|
|
|
Des classes d’opérations pour de grands nombres sont fournies en Java, à savoir la classe java.math.BinInteger et la classe java.math.BigDecimal. Ces deux classes sont utilisées pour le calcul à haute précision, la classe BigInteger étant la classe de traitement des grands entiers et la classe BigDecimal étant la classe de traitement des grands et petits nombres. Ci-dessous, nous introduisons la classe BigDecimal :
L’implémentation de BigDecimal tire parti de BigInteger, sauf que BigDecimal ajoute le concept de décimaux. Les données générales de type flottant et double ne peuvent être utilisées que pour des calculs scientifiques ou d’ingénierie, car en informatique commerciale, la précision numérique requise est relativement élevée, donc la classe java.math.BigDecimal est utilisée, qui supporte toute précision des points fixes, et peut être utilisée pour calculer avec précision les valeurs de monnaie. Ci-dessous, nous présenterons brièvement son utilisation avec des exemples
java.math.BigDecimal
Aujourd’hui, j’ai écrit un programme sur la conversion binaire et décimale en référence au manuel, et l’algorithme du programme n’est pas difficile, mais après avoir écrit, j’ai constaté que, que ce soit 2 à 10 ou 10 à 2, ce n’est pas une bonne conversion pour des nombres supérieurs à 2,1 milliards, c’est-à-dire plus que la plage d’entiers. deviendra 0.
Les ouvrages de référence ont montré que l’utilisation de BigInteger résout ce problème.
J’ai donc cherché le JDK, puis testé plusieurs fois et finalement réussi à l’écrire !
L’expérience d’utilisation est la suivante :
1. BigInteger appartient à java.math.BigInteger, donc importez cette classe avant chaque utilisation. Parfois, j’oubliais d’importer au début, donc la demande ne se trouve pas dans l’invite constante.
2. Il existe de nombreuses méthodes de construction, mais elles sont désormais occasionnellement utilisées :
BigInteger (String val)
Convertir la représentation décimale de la chaîne de BigInteger en BigInteger (BigEntier).
BigInteger (String val, int radix)
Convertit la représentation de la chaîne du BigInteger pour la cardinalité spécifiée en BigInteger.
Pour convertir 2 de type int en type BigEntier, écrivez GrosInteger deux = nouveau GrosEntiers (« 2 ») ; Note 2 : les guillemets doubles ne peuvent pas être omis
3. La classe BigInteger simule toutes les opérations mathématiques de type int, telles que add()=="+ », divide()== »-« , etc., mais notez que son contenu ne peut pas être utilisé directement pour des opérations mathématiques lors de l’exécution d’opérations mathématiques, et doit utiliser ses méthodes internes. Et son opérande doit également être de type BigInteger.
Par exemple : two.add(2) est une opération incorrecte car 2 ne devient pas un type BigEntier.
4. Lorsque vous souhaitez produire les résultats du calcul, vous devez utiliser la méthode .toString pour les convertir en chaîne décimale, comme détaillé ci-dessous :
String toString()
Retourne la représentation décimale de la chaîne de ce BigInteger.
Méthode de sortie : System.out.print(two.toString()) ;
5. Expliquer les trois fonctions utilisées.
BigInteger remainder(BigInteger val)
Retourne un BigInteger avec une valeur de (ce % val).
Néation BigInteger
BigInteger renvoie une valeur de (-this).
int compareTo(BigInteger val)
Comparez ce BigInteger au BigInteger spécifié.
Les restes servaient à trouver le reste.
la négation transforme l’opérande en l’opposé.
La comparaison est expliquée en détail comme suit :
compareTo
public int compareTo(BigInteger val)
Comparez ce BigInteger au BigInteger spécifié. Cette méthode est préférée pour chacun des six opérateurs de comparaison booléens (<, ==, >, >=, !=, <=). L’instruction suggérée pour effectuer ces comparaisons est : (x.compareTo(y) <op> 0), où est <op> l’un des six opérateurs de comparaison.
Spécificateur :
interface<BigInteger> Comparable
Paramètres :
val - Le BigInteger qui compare ce BigInteger à celui-ci.
Précédent:
Titre Implémenter des calculs précis de nombres en virgule flottante en Java Modification (originale)
Mots-clés Java : calcul précis des nombres en virgule flottante
Question posée :
Que verrions-nous si nous compilions et exécutions le programme suivant ?
classe publique Test{
public static void main(String args[]){
System.out.println(0.05+0.01) ;
System.out.println(1.0-0.42) ;
System.out.println(4.015*100) ;
System.out.println (123,3/100) ;
}
};
Tu as bien lu ! Le résultat est : en effet
0.060000000000000005
0.5800000000000001
401.49999999999994
1.2329999999999999
Les simples types float et double en Java ne peuvent pas être exploités. Ce problème se retrouve non seulement en Java, mais aussi dans de nombreux autres langages de programmation. Dans la plupart des cas, les calculs sont exacts, mais vous pouvez essayer encore quelques fois (vous pouvez faire une boucle) pour essayer des erreurs comme celle ci-dessus. Maintenant, je comprends enfin pourquoi il existe un code BCD.
Ce problème est assez sérieux : si vous avez 9,999999999999999999999 yuans, votre ordinateur ne pensera pas que vous pouvez acheter 10 yuans de produits.
Certains langages de programmation proposent des types de monnaie spécialisés pour gérer cette situation, mais Java ne le fait pas. Voyons maintenant comment régler ça.
Arrondi
Notre première réaction est de faire un rounding. La méthode du tour dans la classe de mathématiques ne peut pas être réglée pour garder quelques décimales, nous ne pouvons faire que cela (garder deux places) :
Double round public (double value){
return Math.round(value*100)/100.0 ;
}
Malheureusement, le code ci-dessus ne fonctionne pas, en passant la 4.015 à cette méthode, on retournera 4.01 au lieu de 4.02, comme nous l’avons vu plus haut
4,015*100=401,49999999999994
Par conséquent, si nous voulons faire un arrondi précis, nous ne pouvons pas utiliser de types simples pour effectuer des opérations
java.text.DecimalFormat ne résout pas non plus ce problème :
System.out.println(new java.text.DecimalFormat (« 0.00 »).format (4.025) ;
La sortie est de 4,02
BigDecimal
Ce principe est également mentionné dans le livre « Java efficace », float et double ne peuvent être utilisés que pour des calculs scientifiques ou d’ingénierie, et en informatique d’entreprise, il faut utiliser java.math.BigDecimal. Il y a 4 façons de construire BigDecimal, nous ne nous soucions pas des deux qui sont faites avec BigInteger, donc il y en a deux autres, qui sont :
BigDecimal (double val)
Ça traduit un double en un BigDecimal.
BigDecimal (Val de chaînes)
Traduit la représentation de chaîne d’un BigDecimal en une BigDecimal.
L’API est brièvement décrite et est généralement plus facile à utiliser. Nous pouvons l’utiliser sans même y réfléchir, quel sera le problème ? Quand quelque chose tournait mal, j’ai découvert qu’il existait un paragraphe dans la description détaillée indiquant laquelle des méthodes ci-dessus suffisait :
Note : les résultats de ce constructeur peuvent être quelque peu imprévisibles. On pourrait supposer que le nouveau BigDecimal(.1) est exactement égal à 0,1, mais en réalité il est égal à 0,1000000000000000055511151231257827021181583404541015625. Cela s’explique par le fait que 0,1 ne peut pas être représenté exactement comme un double (ou, d’ailleurs, comme une fraction binaire de toute longueur finie). Ainsi, la valeur longue transmise au constructeur n’est pas exactement égale à 0,1, apparences indépendamment.
Le constructeur (String), en revanche, est parfaitement prévisible : le nouveau BigDecimal(« .1 ») est exactement égal à 0,1, comme on peut s’y attendre. Il est donc généralement recommandé d’utiliser le constructeur (String) en préférence à celui-ci.
Il s’avère que si nous devons calculer avec précision, nous devons utiliser String pour créer BigDecimal ! L’exemple du livre Effective Java utilise String pour créer BigDecimal, mais le livre ne met pas l’accent sur ce point, ce qui peut être une petite erreur.
Solution
Maintenant que nous avons résolu ce problème, le principe est d’utiliser BigDecimal et de veiller à utiliser String.
Mais imaginez que si nous voulons faire une opération d’addition, il faut d’abord convertir deux nombres en virgule flottante en String, puis créer un BigDecimal, appeler la méthode d’addition sur l’un d’eux, passer l’autre comme argument, puis convertir le résultat de l’opération (BigDecimal) en nombre en virgule flottante. Pouvez-vous supporter un processus aussi fastidieux ? Ci-dessous, nous fournissons une classe d’outils Arith pour simplifier l’opération. Il propose les méthodes statiques suivantes, incluant addition, soustraction, multiplication et division, ainsi que l’arrondi :
Double Addition statique publique (double v1, double v2)
Public Static Double Sub (double v1, double v2)
Public Static Double Mul(double v1, double v2)
Public Static double div(double v1, double v2)
Public Static double div (double v1, double v2, échelle INT)
Double round statique public (double v, échelle INT)
Annexe
Fichier source Arith.java :
importer java.math.BigDecimal ;
/**
* Puisque les types simples de Java ne peuvent pas effectuer avec précision des opérations en virgule flottante, cette classe d’outils offre des amendes
* Opérations exactes en virgule flottante, incluant addition, soustraction, multiplication, division et arrondi.
*/
classe publique Arith{
Précision par défaut des opérations de division
Privé statique final int DEF_DIV_SCALE = 10 ;
Cette classe ne peut pas être instanciée
privé Arith(){
}
/**
* Fournit des opérations d’addition précises.
* @param v1 est ajoutée
* @param ajout v2
* @return La somme des deux paramètres
*/
public statique double add(double v1,double v2){
BigDecimal b1 = nouveau BigDecimal(Double.toString(v1)) ;
BigDecimal b2 = nouveau BigDecimal(Double.toString(v2)) ;
return b1.add(b2).doubleValue() ;
}
/**
* Fournit des opérations de soustraction précises.
* @param v1 est soustraite
* @param v2 moins
* @return La différence entre les deux paramètres
*/
public static double sub(double v1,double v2){
BigDecimal b1 = nouveau BigDecimal(Double.toString(v1)) ;
BigDecimal b2 = nouveau BigDecimal(Double.toString(v2)) ;
return b1.subtract(b2).doubleValue() ;
}
/**
* Fournit des opérations de multiplication précises.
* @param v1 est multiplié
* @param multiplicateur v2
* @return Le produit des deux paramètres
*/
public statique double mul(double v1,double v2){
BigDecimal b1 = nouveau BigDecimal(Double.toString(v1)) ;
BigDecimal b2 = nouveau BigDecimal(Double.toString(v2)) ;
return b1.multiply(b2).doubleValue() ;
}
/**
* Fournit des opérations de division (relativement) précises, lorsque la division inépuisable se produit
* 10 décimales et les chiffres suivants sont arrondis.
* @param v1 est divisé
* @param diviseur v2
* @return Le quotient des deux paramètres
*/
public static double div(double v1,double v2){
retour div(v1,v2,DEF_DIV_SCALE) ;
}
/**
* Fournit des opérations de division (relativement) précises. Lorsqu’une situation inépuisable se produit, elle est indiquée par le paramètre d’échelle
* Déterminer la précision, et les chiffres après seront arrondis.
* @param v1 est divisé
* @param diviseur v2
* @param échelle indique qu’elle doit être précise à quelques décimales.
* @return Le quotient des deux paramètres
*/
public static double div(double v1,double v2,int scale){
if(scale<0){
lancer une nouvelle IllegalArgumentException(
« L’échelle doit être un entier positif ou zéro ») ;
}
BigDecimal b1 = nouveau BigDecimal(Double.toString(v1)) ;
BigDecimal b2 = nouveau BigDecimal(Double.toString(v2)) ;
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue() ;
}
/**
* Fournit un arrondi décimal précis.
* @param v nécessite d’arrondir les nombres
* @param échelle est réservée après la virgule
* @return Résultats arrondis
*/
Double round statique public (double v,int scale){
if(scale<0){
lancer une nouvelle IllegalArgumentException(
« L’échelle doit être un entier positif ou zéro ») ;
}
BigDecimal b = nouveau BigDecimal(Double.toString(v)) ;
BigDecimal un = nouveau BigDecimal(« 1 ») ;
return b.divide(un,scale,BigDecimal.ROUND_HALF_UP).doubleValue() ;
}
}; |
Précédent:Il vaut mieux ne pas composer une corde dont le sens est une tonalité primaireProchain:Différences et connexions entre JDK, JRE, JVM
|
