Analyse de code d'exemple d'application de classe Java BigDecimal

1. Introduction

L'objectif principal de la conception des types flotteur et double concerne les calculs scientifiques et les calculs techniques. Ils effectuent des opérations binaires à virgule flottante, soigneusement conçues pour fournir des calculs approximatifs rapides avec une grande précision sur une large plage de valeurs. Cependant, ils ne fournissent pas de résultats totalement précis et ne doivent pas être utilisés lorsque des résultats précis sont requis. Cependant, les calculs commerciaux nécessitent souvent des résultats précis, et BigDecimal s'avère utile en ce moment.

2. 5. Résumé

• 6. Exercices de raffinement

• 3. Explication détaillée des points de connaissance

1.

• Démonstration de code :

• package com.Test;
  
  import Test2.MyDate;
  import java.awt.*;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.GregorianCalendar;
  import java.util.Properties;
  
  public class Main {
  private final static String name = "磊哥的java历险记-@51博客";
  public static void main(String[] args) {
  System.out.println(0.2 + 0.1);
  System.out.println(0.3 - 0.1);
  System.out.println(0.2 * 0.1);
  System.out.println(0.3 / 0.1);
  System.out.println("============="+name+"=============");
  }
  }

• Vous pensez avoir mal vu, mais le résultat est comme ça. Quel est le problème ? La raison en est que nos ordinateurs sont binaires. Il n'existe aucun moyen de représenter avec précision les nombres à virgule flottante en binaire. Notre CPU représente que les nombres à virgule flottante sont composés de deux parties : l'exposant et la mantisse. Cette méthode de représentation perd généralement un certain degré de précision, et certaines opérations sur les nombres à virgule flottante produiront également certaines erreurs. Par exemple : la représentation binaire de 2,4 n'est pas exactement 2,4. Au lieu de cela, la représentation binaire la plus proche est 2,3999999999999999. La valeur d'un nombre à virgule flottante est en fait calculée par une formule mathématique spécifique.
  En fait, le float de Java ne peut être utilisé que pour des calculs scientifiques ou des calculs techniques. Dans la plupart des calculs commerciaux, la classe java.math.BigDecimal est généralement utilisée pour des calculs précis.
• 2. Méthode de construction BigDecimal

(1) public BigDecimal(double val) : Convertir la représentation double en BigDecimal (Remarque : Non recommandé)

(2) public BigDecimal(int val) : Convertir la représentation int en BigDecimal

(3) public BigDecimal(String val) : Convertir la représentation String en BigDecimal

Pourquoi n'est-il pas recommandé d'utiliser la première méthode de construction ?

Démonstration de code :

package com.Test;

import Test2.MyDate;

import java.awt.*;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Properties;

public class Main {

private final static String name = "磊哥的java历险记-@51博客";

public static void main(String[] args){
BigDecimal bigDecimal =new BigDecimal(2);
BigDecimal bDouble = new BigDecimal(2.3);
BigDecimal bString = new BigDecimal("2.3");
System.out.println("bigDecimal="+ bigDecimal);
System.out.println("bDouble="+ bDouble);
System.out.println("bString="+ bString);
System.out.println("============="+name+"=============");
}
}

Les résultats d'exécution sont les suivants :

• Pourquoi cela se produit-il ?
  3. Description du code source
• Le résultat de la méthode de construction avec le type de paramètre double est quelque peu imprévisible. On pourrait penser que la rédaction de NewBigDecimal (0,1) en Java crée un BigDecimal qui est exactement égal à 0,1 (la valeur non à l'échelle de 1, qui a une échelle de 1), mais elle est en fait égale à 0,10000000000000000005551115123
  125782702118158404541015625. En effet, 0,1 ne peut pas être représenté exactement comme un double (ou, dans ce cas, comme n'importe quel nombre décimal binaire de longueur finie). Ainsi, la valeur transmise au constructeur ne sera pas exactement égale à 0,1 (même si elle semblera être égale à cette valeur).

Le constructeur String, en revanche, est complètement prévisible : écrire newBigDecimal("0.1") créera un BigDecimal exactement égal au 0,1 attendu. Par conséquent, en comparaison, il est généralement recommandé d’utiliser de préférence le constructeur String.

Lorsque double doit être utilisé comme source de BigDecimal, veuillez utiliser Double.toString(double) pour convertir en String, puis utilisez le constructeur String, ou utilisez la méthode statique valueOf de BigDecimal

Démonstration de code :

package com.Test;
import Test2.MyDate;
import java.math.BigDecimal;
public class Main {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args) {
BigDecimal bDouble1 =BigDecimal.valueOf(2.3);
BigDecimal bDouble2 = new BigDecimal(Double.toString(2.3));
System.out.println("bDouble1="+ bDouble1);
System.out.println("bDouble2="+ bDouble2);
System.out.println("============="+name+"=============");
}
}

Les résultats sont les suivants :

4. Opérations d'addition, de soustraction, de multiplication et de division BigDecimal

Pour les additions, soustractions, multiplications et divisions couramment utilisées, la classe BigDecimal fournit les méthodes membres correspondantes.

(1) public BigDecimal add(BigDecimal value); addition

(2) public BigDecimal subtract(BigDecimal value); /Multiply Indivisibility , tel que 4.5/1.3, puis l'erreur java.lang.ArithmeticException:Non-terminating decimal expansion; no exact représentable decimal result.

En fait, la méthode de division peut transmettre trois paramètres :

public BigDecimal divide(BigDecimal divisor, int scale, introundingMode) 第一参数表示除数， 第二个参数表示小数点后保留位数， 第三个参数表示舍入模式，只有在作除法运算或四舍五入时才用到舍入模式，有下面这几种

• （1）ROUND_CEILING //向正无穷方向舍入

• （2）ROUND_DOWN //向零方向舍入

• （3）ROUND_FLOOR //向负无穷方向舍入

• （4）ROUND_HALF_DOWN //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5

• （5）ROUND_HALF_EVEN //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN

• （6）ROUND_HALF_UP //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6

• （7）ROUND_UNNECESSARY //计算结果是精确的，不需要舍入模式

• （8）ROUND_UP //向远离0的方向舍入

按照各自的需要，可传入合适的第三个参数。四舍五入采用 ROUND_HALF_UP

需要对BigDecimal进行截断和四舍五入可用setScale方法，例：

代码演示：

public static void main(String[] args) {
BigDecimal a = newBigDecimal("4.5635");
//保留3位小数，且四舍五入
a = a.setScale(3,RoundingMode.HALF_UP);
System.out.println(a);
}

注：减乘除其实最终都返回的是一个新的BigDecimal对象，因为BigInteger与BigDecimal都是不可变的（immutable）的，在进行每一步运算时，都会产生一个新的对象

代码演示：

package com.Test;
import Test2.MyDate;
import java.math.BigDecimal;
public class Main {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args){
BigDecimal a = new BigDecimal("4.5");
BigDecimal b = new BigDecimal("1.5");
a. add(b);
System.out.println(a); //输出4.5. 加减乘除方法会返回一个新的
System.out.println("============="+name+"=============");
}
}

5、总结

• (1)商业计算使用BigDecimal。

• (2)尽量使用参数类型为String的构造函数。

• (3)BigDecimal都是不可变的（immutable）的，在进行每一步运算时，都会产wf 所以在做加减乘除运算时千万要保存操作后的值。

• (4)我们往往容易忽略JDK底层的一些实现细节，导致出现错误，需要多加注意。

6、精炼练习

在银行结算或支付中，我们经常会用到BigDecimal的相关方法。

6.1 题目

• （1）使用BigDecimal创建出浮点类型的数字

• （2）使用BigDecimal进行加减乘除运算

6.2 实验步骤

• （1）声明一个类Test

• （2）在Test类中，完成BigDecimal的构造和方法使用

代码演示：

package com.Test;
import Test2.MyDate;
import java.math.BigDecimal;
public class Main {
private final static String name = "磊哥的java历险记-@51博客";
public static void main(String[] args){
BigDecimal number = new BigDecimal("3.14");
//加法
System.out.println(number.add(new BigDecimal("1")));
//减法
System.out.println(number.subtract(new BigDecimal("1")));
//乘法
System.out.println(number.multiply(new BigDecimal("2")));
//除法
System.out.println(number.multiply(new BigDecimal("3.14")));
System.out.println("============="+name+"=============");
}
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!