JAVA BigDecimal总结

曾经终败给现在 2022-10-25 11:20 198阅读 0赞

> **目录**
> 
> 摘要
> 
> 一、前言
> 
> 二、BigDecimal构造方法
> 
> 三、BigDecimal加减乘除运算
> 
> 四、BigDecimal比较大小
> 
> 五、BigDecimal转String
> 
> 六、总结
> 
> 七、常见问题汇总
> 
> --------------------
> 
> ### 摘要 ###
> 
>     public static void main(String[] args)
>         {
>             BigDecimal a = new BigDecimal("4.5");
>             BigDecimal b = new BigDecimal("1.5");
>     
>             System.out.println("a + b =" + a.add(b));
>             System.out.println("a - b =" + a.subtract(b));
>             System.out.println("a * b =" + a.multiply(b));
>             System.out.println("a / b =" + a.divide(b));
>         }
> 
> ### 一、前言 ###
> 
> 　　float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供完全精确的结果，所以不应该被用于要求精确结果的场合。但是，商业计算往往要求结果精确，这时候BigDecimal就派上大用场啦。
> 
> **代码**
> 
>     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);
>         }
> 
> 运行结果如下
> 
> ![20210131140841685.png][]
> 
>    　你认为你看错了，但结果却是是这样的。问题在哪里呢？原因在于我们的计算机是二进制的。浮点数没有办法是用二进制进行精确表示。我们的CPU表示浮点数由两个部分组成：指数和尾数，这样的表示方法一般都会失去一定的精确度，有些浮点数运算也会产生一定的误差。如：2.4的二进制表示并非就是精确的2.4。反而最为接近的二进制表示是 2.3999999999999999。浮点数的值实际上是由一个特定的数学公式计算得到的。
> 
>  　　其实java的float只能用来进行科学计算或工程计算，在大多数的商业计算中，一般采用java.math.BigDecimal类来进行精确计算。
> 
> ### 二、BigDecimal构造方法 ###
> 
>     public BigDecimal(double val)    将double表示形式转换为BigDecimal *不建议使用
>     public BigDecimal(int val)　　将int表示形式转换成BigDecimal
>     public BigDecimal(String val)　　将String表示形式转换成BigDecimal
> 
> 为什么不建议采用第一种构造方法呢？来看例子
> 
>     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);
>         }
> 
> 运行结果如下
> 
> ![e372421a86701c44c44fc7fa17e8400c.png][]
> 
> 为什么会出现这种情况呢？
> 
> 　　JDK的描述：
> 
> 　　1、参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。
> 
>         2、另一方面，String 构造方法是完全可预知的：写入 newBigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，**通常建议优先使用String构造方法**。
> 
> **当double必须用作BigDecimal的源时，**请使用`Double.toString(double)``转成String，然后`使用String构造方法，或使用BigDecimal的静态方法valueOf，如下
> 
>     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);
>             
>         }
> 
> 结果如下
> 
> ![83d8b9868355c6354bda80d2b540d912.png][]
> 
> ### 三、BigDecimal加减乘除运算 ###
> 
> 对于常用的加，减，乘，除，BigDecimal类提供了相应的成员方法。
> 
>     public BigDecimal add(BigDecimal value);                        //加法
>     public BigDecimal subtract(BigDecimal value);                   //减法 
>     public BigDecimal multiply(BigDecimal value);                   //乘法
>     public BigDecimal divide(BigDecimal value);                     //除法
> 
> 大概的用法如下
> 
>     public static void main(String[] args)
>         {
>             BigDecimal a = new BigDecimal("4.5");
>             BigDecimal b = new BigDecimal("1.5");
>     
>             System.out.println("a + b =" + a.add(b));
>             System.out.println("a - b =" + a.subtract(b));
>             System.out.println("a * b =" + a.multiply(b));
>             System.out.println("a / b =" + a.divide(b));
>         }
> 
> 运行结果
> 
> ![7340b28f49587c65b92c3ef1126bcf70.png][]
> 
> 这里有一点需要注意的是除法运算divide.
> 
> BigDecimal除法可能出现不能整除的情况，比如 4.5/1.3，这时会报错java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
> 
> 其实divide方法有可以传三个参数
> 
>     public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
> 
> 第一参数表示除数， 二个参数表示小数点后保留位数，第三个参数表示舍入模式。
> 
> 只有在作除法运算或四舍五入时才用到舍入模式，有下面这几种：
> 
>     　　在银行、帐户、计费等领域，BigDecimal提供了精确的数值计算。其中8种舍入方式值得掌握。
>     
>     1、ROUND_UP
>     
>     　　舍入远离零的舍入模式。
>     
>     　　在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1)。
>     
>     　　注意，此舍入模式始终不会减少计算值的大小。
>     
>     2、ROUND_DOWN
>     
>     　　接近零的舍入模式。
>     
>     　　在丢弃某部分之前始终不增加数字(从不对舍弃部分前面的数字加1，即截短)。
>     
>     　　注意，此舍入模式始终不会增加计算值的大小。
>     
>     3、ROUND_CEILING
>     
>     　　接近正无穷大的舍入模式。
>     
>     　　如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同;
>     
>     　　如果为负，则舍入行为与 ROUND_DOWN 相同。
>     
>     　　注意，此舍入模式始终不会减少计算值。
>     
>     4、ROUND_FLOOR
>     
>     　　接近负无穷大的舍入模式。
>     
>     　　如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同;
>     
>     　　如果为负，则舍入行为与 ROUND_UP 相同。
>     
>     　　注意，此舍入模式始终不会增加计算值。
>     
>     5、ROUND_HALF_UP
>     
>     　　向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
>     
>     　　如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同。
>     
>     　　注意，这是我们大多数人在小学时就学过的舍入模式(四舍五入)。
>     
>     6、ROUND_HALF_DOWN
>     
>     　　向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。
>     
>     　　如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同(五舍六入)。
>     
>     7、ROUND_HALF_EVEN    银行家舍入法
>     
>     　　向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
>     
>     　　如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同;
>     
>     　　如果为偶数，则舍入行为与 ROUND_HALF_DOWN 相同。
>     
>     　　注意，在重复进行一系列计算时，此舍入模式可以将累加错误减到最小。
>     
>     　　此舍入模式也称为“银行家舍入法”，主要在美国使用。四舍六入，五分两种情况。
>     
>     　　如果前一位为奇数，则入位，否则舍去。
>     
>     　　以下例子为保留小数点1位，那么这种舍入方式下的结果。
>     
>     　　1.15>1.2 1.25>1.2
>     
>     8、ROUND_UNNECESSARY
>     
>     　　断言请求的操作具有精确的结果，因此不需要舍入。
>     
>     　　如果对获得精确结果的操作指定此舍入模式，则抛出ArithmeticException。
>     
>      
>     
>     因为我们是属于互联网金融行业，所有在进行计算的时候尽量使用ROUND_HALF_EVEN    银行家舍入法
> 
> 按照各自的需要，可传入合适的第三个参数。**四舍五入采用 ROUND\_HALF\_UP**
> 
> 需要对BigDecimal进行截断和四舍五入可用setScale方法，例：
> 
>     public static void main(String[] args)
>         {
>             BigDecimal a = new BigDecimal("4.5635");
>     
>             a = a.setScale(3, RoundingMode.HALF_UP);    //保留3位小数，且四舍五入
>             System.out.println(a);
>         }
> 
>     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. 加减乘除方法会返回一个新的BigDecimal对象，原来的a不变
>     
>     
>         }
> 
> ### 四、BigDecimal比较大小 ###
> 
>     BigDecimal a = new BigDecimal (101);
>     BigDecimal b = new BigDecimal (111);
>      
>     //使用compareTo方法比较
>     //注意：a、b均不能为null，否则会报空指针
>     if(a.compareTo(b) == -1){
>         System.out.println("a小于b");
>     }
>      
>     if(a.compareTo(b) == 0){
>         System.out.println("a等于b");
>     }
>      
>     if(a.compareTo(b) == 1){
>         System.out.println("a大于b");
>     }
>      
>     if(a.compareTo(b) > -1){
>         System.out.println("a大于等于b");
>     }
>      
>     if(a.compareTo(b) < 1){
>         System.out.println("a小于等于b");
>     }
> 
> ### 五、BigDecimal转String ###
> 
>     public static void main(String[] args) {
>             // 浮点数的打印
>             System.out.println(new BigDecimal("10000000000").toString());
>     
>             // 普通的数字字符串
>             System.out.println(new BigDecimal("100.000").toString());
>     
>             // 去除末尾多余的0
>             System.out.println(new BigDecimal("100.000").stripTrailingZeros().toString());
>     
>             // 避免输出科学计数法
>             System.out.println(new BigDecimal("100.000").stripTrailingZeros().toPlainString());
>     
>     }
>     
>     // output
>     10000000000
>     100.000
>     1E+2
>     100
> 
> 1.  用toString()方法输出的就是普通的数字字符串。
> 2.  stripTrailingZeros()函数就是用于去除末尾多余的0的，
> 3.  用toPlainString()函数代替toString(),避免输出科学计数法的字符串。
> 
> ### 六、总结 ###
> 
> 1.  商业计算使用BigDecimal。
> 2.  尽量使用参数类型为String的构造函数。
> 3.  BigDecimal都是不可变的（immutable）的，在进行每一步运算时，都会产生一个新的对象，所以在做加减乘除运算时千万要保存操作后的值。
> 
> ### 七、常见问题汇总 ###
> 
> **1）、BigDecimal显示类似为2E10**
> 
>     BigDecimal money = new BigDecimal();
>     String moneyStr = money.stripTrailingZeros().toPlainString();
> 
> **2）、java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result**
> 
> 这个问题产生是使用BigDecimal做除法(divide)运算，这个类的divide方法存在三个常用的构造函数。
> 
> <table> 
>  <tbody> 
>   <tr> 
>    <td style="vertical-align:top;"><code>BigDecimal</code></td> 
>    <td><code><strong>divide</strong>(BigDecimal&nbsp;divisor)</code>&nbsp;<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Returns a&nbsp;<code>BigDecimal</code>&nbsp;whose value is&nbsp;<code>(this / divisor)</code>, and whose preferred scale is&nbsp;<code>(this.scale() - divisor.scale())</code>; if the exact quotient cannot be represented (because it has a non-terminating decimal expansion) an&nbsp;<code>ArithmeticException</code>&nbsp;is thrown.</td> 
>   </tr> 
>   <tr> 
>    <td style="vertical-align:top;"><code>&nbsp;<a href="https://docs.oracle.com/javase/6/docs/api/java/math/BigDecimal.html" rel="nofollow">BigDecimal</a></code></td> 
>    <td><code><strong><a href="https://docs.oracle.com/javase/6/docs/api/java/math/BigDecimal.html#divide%28java.math.BigDecimal,%20int%29" rel="nofollow">divide</a></strong>(<a href="https://docs.oracle.com/javase/6/docs/api/java/math/BigDecimal.html" rel="nofollow">BigDecimal</a>&nbsp;divisor, int&nbsp;roundingMode)</code>&nbsp;<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Returns a&nbsp;<code>BigDecimal</code>&nbsp;whose value is&nbsp;<code>(this / divisor)</code>, and whose scale is&nbsp;<code>this.scale()</code>.</td> 
>   </tr> 
>   <tr> 
>    <td style="vertical-align:top;"><code>&nbsp;<a href="https://docs.oracle.com/javase/6/docs/api/java/math/BigDecimal.html" rel="nofollow">BigDecimal</a></code></td> 
>    <td><code><strong><a href="https://docs.oracle.com/javase/6/docs/api/java/math/BigDecimal.html#divide%28java.math.BigDecimal,%20int,%20int%29" rel="nofollow">divide</a></strong>(<a href="https://docs.oracle.com/javase/6/docs/api/java/math/BigDecimal.html" rel="nofollow">BigDecimal</a>&nbsp;divisor, int&nbsp;scale, int&nbsp;roundingMode)</code>&nbsp;<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Returns a&nbsp;<code>BigDecimal</code>&nbsp;whose value is&nbsp;<code>(this / divisor)</code>, and whose scale is as specified.</td> 
>   </tr> 
>  </tbody> 
> </table>
> 
> 在第一个构造方法中，可以只传入被除数（divisor）。但是调用这个方法极容易出现一个错误，当除不尽时候，会产生无限循环小数，这时将会抛出异常：
> 
> 在第二个或者第三个构造方法中，指定了当除不尽的时候，进行有效位数的保留，因此会比较安全。
> 
> 解决的办法就是给divide方法设置精确的小数点，如：divide(xxxxx,2)，这样就可以精确到小数点后两位，重新运行程序，你就会发现不会再报错了。
> 
>

[20210131140841685.png]: /images/20221024/b90a1d908c7747958ba382e62fd591a6.png
[e372421a86701c44c44fc7fa17e8400c.png]: /images/20221024/fd04725e595945129d5d5138f17078c7.png
[83d8b9868355c6354bda80d2b540d912.png]: /images/20221024/e0e7e80a8905402bb01ebfc121ea3007.png
[7340b28f49587c65b92c3ef1126bcf70.png]: /images/20221024/deda1e21d00c4bcc8ffc9c8a8ec2b442.png