Java BigDecimal

1、经典问题：浮点数精度丢失

精度丢失的问题是在其他计算机语言中也都会出现，float和double类型的数据在执行二进制浮点运算的时候，并没有提供完全精确的结果。产生误差不在于数的大小，而是因为数的精度。

float和double

float 单精度浮点数在机内占 4 个字节，用 32 位二进制描述
double 双精度浮点数在机内占 8 个字节，用 64 位二进制描述
注意float型定义的数据末尾必须有”f”或”F”，为了和double区别
来写一段简单的程序来实验一下为什么它不行

  1.  System.out.println(2.0-1.4);

如果是有经验的开发人员，肯定觉得这么写出来是不是有问题？这直接减法减出来的数据应该不对，是的，结果肯定不对。

  1. 0.6000000000000001

为什么运算结果有问题呢？那加法和乘法是不是都会有这种问题，确实会有这种问题，而这个问题，就得从计算机去开始讨论了，计算机并不能识别除了二进制数据以外的任何数据。也就是说，传递给计算机的是十进制的数据，但是计算机需要先把给的数据转换成二进制的数据，因为不能直接识别十进制的数据，这时候，2.0 是十进制的数据，转换成二进制的数据，而1.4呢？转换成二进制的数据反而出现了问题 1.4在二进制中，则是会出现1.399999。。。这样的数据，当进行数据转换的时候，就出现了2.0-1.399999这样的数据。
这个时候就有人问了，定义 float 类型为 1.4 的时候为什么不是 1.399999999呢？这就是不进行浮点计算的时候，在十进制里浮点数能正确显示。也就是说，如果知识定义了类型为 float 的话，但是不用这个数字去进行计算，那就没问题，但是一旦参与了运算，那就不行了。
这里简单讨论一下十进制数转二进制为什么会出现精度丢失的现象，十进制数分为整数部分和小数部分，分开来看看就知道原因为何：

十进制整数如何转化为二进制整数？

将被除数每次都除以2，只要除到商为0就可以停止这个过程。

  1. 5 / 2 = 2 余 1
  2. 2 / 2 = 1 余 0
  3. 1 / 2 = 0 余 1 
  4. // 结果为 101

这个算法永远都不会无限循环，整数永远都可以使用二进制数精确表示，但小数呢？

十进制小数如何转化为二进制数？

每次将小数部分乘2，取出整数部分，如果小数部分为0，就可以停止这个过程。

  1. 0.1 * 2 = 0.2 取整数部分0
  2. 0.2 * 2 = 0.4 取整数部分0
  3. 0.4 * 2 = 0.8 取整数部分0
  4. 0.8 * 2 = 1.6 取整数部分1
  5. 0.6 * 2 = 1.2 取整数部分1
  6. 0.2 * 2 = 0.4 取整数部分0 
  7. //... 写到这就不必再写了，应该已经发现，
  8. // 上面的过程已经开始循环，小数部分永远不能为0

这个算法有一定概率会存在无限循环，即无法用有限长度的二进制数表示十进制的小数，这就是精度丢失问题产生的原因。

阿里手册定义

数据库 小数类型为 decimal，禁止使用 float 和 double。
在存储的时候，float 和 double 都存在精度损失的问题，很可能在比较值的时候，得到不正确的结果。如果存储的数据范围超过 decimal 的范围，建议将数据拆成整数和小数并分开存储。
Java程序：使用 BigDecimal 来定义值，再进行浮点数的运算操作
BigDecimal 是 Java 在 java.math 包中提供的API类，用来对超过16位有效位的数进行精确的运算

2、BigDecimal概述

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。
一般情况下，对于那些不需要准确计算精度的数字可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果需要精确计算的结果，则必须使用BigDecimal类来操作。
BigDecimal所创建的是对象，故不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

3、BigDecimal常用构造函数

3.1、常用构造函数

  • BigDecimal(int)：创建一个具有参数所指定整数值的对象
  • BigDecimal(double)：创建一个具有参数所指定双精度值的对象
  • BigDecimal(long)：创建一个具有参数所指定长整数值的对象

  • BigDecimal(String)：创建一个具有参数所指定以字符串表示的数值的对象

    3.2、使用问题分析

    使用示例：

    1. BigDecimal a =new BigDecimal(0.1);
    2. System.out.println("a values is:"+a);
    3. System.out.println("=====================");
    4. BigDecimal b =new BigDecimal("0.1");
    5. System.out.println("b values is:"+b);

    结果示例：

    1. a values is:0.1000000000000000055511151231257827021181583404541015625
    2. =====================
    3. b values is:0.1

    原因分析：
    1）参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入new BigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。
    2）String 构造方法是完全可预知的：写入 new BigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言， 通常建议优先使用String构造方法。
    3）当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。
    其实在点击到这个方法看源码的时候，注释都提醒慎重使用了。

    1. * The results of this constructor can be somewhat unpredictable.     这个构造函数可以有些不可预测的结果
    2. * One might assume that writing {@code new BigDecimal(0.1)} in
    3. * Java creates a {@code BigDecimal} which is exactly equal to
    4. * 0.1 (an unscaled value of 1, with a scale of 1), but it is
    5. * actually equal to
    6. * 0.1000000000000000055511151231257827021181583404541015625.
    7. * This is because 0.1 cannot be represented exactly as a
    8. * {@code double} (or, for that matter, as a binary fraction of
    9. * any finite length).  Thus, the value that is being passed
    10. * <i>in</i> to the constructor is not exactly equal to 0.1,
    11. * appearances notwithstanding.

    也就是说存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常

    4、BigDecimal常用方法详解

    4.1、常用方法

  • add(BigDecimal)：BigDecimal对象中的值相加，返回BigDecimal对象

  • subtract(BigDecimal)：BigDecimal对象中的值相减，返回BigDecimal对象
  • multiply(BigDecimal)：BigDecimal对象中的值相乘，返回BigDecimal对象
  • divide(BigDecimal)：BigDecimal对象中的值相除，返回BigDecimal对象
  • toString()：将BigDecimal对象中的值转换成字符串
  • doubleValue()：将BigDecimal对象中的值转换成双精度数
  • floatValue()：将BigDecimal对象中的值转换成单精度数
  • longValue()：将BigDecimal对象中的值转换成长整数

  • intValue()：将BigDecimal对象中的值转换成整数

    4.2、BigDecimal大小比较

    Java中对BigDecimal比较大小一般用的是bigdemical的compareTo方法

    1. int a = bigdemical.compareTo(bigdemical2)

    返回结果分析：

    1. a = -1,表示bigdemical小于bigdemical2；
    2. a = 0,表示bigdemical等于bigdemical2；
    3. a = 1,表示bigdemical大于bigdemical2；

    举例：a大于等于b

    1. new bigdemica(a).compareTo(new bigdemical(b)) >= 0

    4.3、BigDecimal保留小数点问题

    ROUND_DOWN：向零方向舍入
    ROUND_UP：向远离0的方向舍入
    ROUND_CEILING：向正无穷方向舍入
    ROUND_FLOOR：向负无穷方向舍入
    ROUND_HALF_DOWN：相当于五舍六入
    ROUND_HALF_UP：相当于四舍五入(经常使用)

    5、BigDecimal格式化

    由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。
    以利用BigDecimal对货币和百分比格式化为例。首先，创建BigDecimal对象，进行BigDecimal的算术运算后，分别建立对货币和百分比格式化的引用，最后利用BigDecimal对象作为format()方法的参数，输出其格式化的货币值和百分比。

    1. NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用 
    2. NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用 
    3. percent.setMaximumFractionDigits(3); //百分比小数点最多3位 
    4. BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
    5. BigDecimal interestRate = new BigDecimal("0.008"); //利率   
    6. BigDecimal interest = loanAmount.multiply(interestRate); //相乘
    7. System.out.println("贷款金额:\t" + currency.format(loanAmount)); 
    8. System.out.println("利率:\t" + percent.format(interestRate)); 
    9. System.out.println("利息:\t" + currency.format(interest));

    结果：

    1. 贷款金额: ￥15,000.48 利率: 0.8% 利息: ￥120.00

    BigDecimal格式化保留2为小数，不足则补0： ```java public class NumberFormat { public static void main(String[] s){

    1.   System.out.println(formatToNumber(new BigDecimal("3.435")));
    2.   System.out.println(formatToNumber(new BigDecimal(0)));
    3.   System.out.println(formatToNumber(new BigDecimal("0.00")));
    4.   System.out.println(formatToNumber(new BigDecimal("0.001")));
    5.   System.out.println(formatToNumber(new BigDecimal("0.006")));
    6.   System.out.println(formatToNumber(new BigDecimal("0.206")));

    } /**

    • @desc 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。
    • 2.传入的参数等于0，则直接返回字符串”0.00”
    • 3.大于1的小数，直接格式化返回字符串
    • @param obj传入的小数

    • @return */ public static String formatBigDecimalToStr(BigDecimal obj) { DecimalFormat df = new DecimalFormat(“#.00”); if(obj.compareTo(BigDecimal.ZERO)==0) {

      1.  return "0.00";

      }else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){

      1.  return "0"+df.format(obj).toString();

      }else {

      1.  return df.format(obj).toString();

      } }

      // 简化版 public static String formatBigDecimalToStr(BigDecimal premium) { final DecimalFormat decimalFormat = new DecimalFormat(“#0.00”); return decimalFormat.format(premium); }

}

  1. 结果为：

3.44 0.00 0.00 0.00 0.01 0.21

  1. <a name="5J3xi"></a>
  2. ## 6、`BigDecimal`常见异常
  3. <a name="SjZ6C"></a>
  4. ### 6.1、除法的时候出现异常
  5. `java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result`<br />原因分析：<br />通过`BigDecimal`的`divide`方法进行除法时当不整除，出现无限循环小数时，就会抛异常：
  6. ```java
  7. java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

解决方法：

divide方法设置精确的小数点，如：divide(xxxxx,2)

7、BigDecimal总结

7.1、总结

在需要精确的小数计算时再使用BigDecimal，BigDecimal的性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。
尽量使用参数类型为String的构造函数。
BigDecimal都是不可变的（immutable）的， 在进行每一次四则运算时，都会产生一个新的对象 ，所以在做加减乘除运算时要记得要保存操作后的值。

7.2、工具类推荐

  1. package com.vivo.ars.util;
  2. import java.math.BigDecimal;
  3. /**
  4.  * 用于高精确处理常用的数学运算
  5.  */
  6. public class ArithmeticUtils {
  7.     //默认除法运算精度
  8.     private static final int DEF_DIV_SCALE = 10;
  9.     /**
  10.      * 提供精确的加法运算
  11.      *
  12.      * @param v1 被加数
  13.      * @param v2 加数
  14.      * @return 两个参数的和
  15.      */
  16.     public static double add(double v1, double v2) {
  17.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  18.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  19.         return b1.add(b2).doubleValue();
  20.     }
  21.     /**
  22.      * 提供精确的加法运算
  23.      *
  24.      * @param v1 被加数
  25.      * @param v2 加数
  26.      * @return 两个参数的和
  27.      */
  28.     public static BigDecimal add(String v1, String v2) {
  29.         BigDecimal b1 = new BigDecimal(v1);
  30.         BigDecimal b2 = new BigDecimal(v2);
  31.         return b1.add(b2);
  32.     }
  33.     /**
  34.      * 提供精确的加法运算
  35.      *
  36.      * @param v1    被加数
  37.      * @param v2    加数
  38.      * @param scale 保留scale 位小数
  39.      * @return 两个参数的和
  40.      */
  41.     public static String add(String v1, String v2, int scale) {
  42.         if (scale < 0) {
  43.             throw new IllegalArgumentException(
  44.                     "The scale must be a positive integer or zero");
  45.         }
  46.         BigDecimal b1 = new BigDecimal(v1);
  47.         BigDecimal b2 = new BigDecimal(v2);
  48.         return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  49.     }
  50.     /**
  51.      * 提供精确的减法运算
  52.      *
  53.      * @param v1 被减数
  54.      * @param v2 减数
  55.      * @return 两个参数的差
  56.      */
  57.     public static double sub(double v1, double v2) {
  58.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  59.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  60.         return b1.subtract(b2).doubleValue();
  61.     }
  62.     /**
  63.      * 提供精确的减法运算。
  64.      *
  65.      * @param v1 被减数
  66.      * @param v2 减数
  67.      * @return 两个参数的差
  68.      */
  69.     public static BigDecimal sub(String v1, String v2) {
  70.         BigDecimal b1 = new BigDecimal(v1);
  71.         BigDecimal b2 = new BigDecimal(v2);
  72.         return b1.subtract(b2);
  73.     }
  74.     /**
  75.      * 提供精确的减法运算
  76.      *
  77.      * @param v1    被减数
  78.      * @param v2    减数
  79.      * @param scale 保留scale 位小数
  80.      * @return 两个参数的差
  81.      */
  82.     public static String sub(String v1, String v2, int scale) {
  83.         if (scale < 0) {
  84.             throw new IllegalArgumentException(
  85.                     "The scale must be a positive integer or zero");
  86.         }
  87.         BigDecimal b1 = new BigDecimal(v1);
  88.         BigDecimal b2 = new BigDecimal(v2);
  89.         return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  90.     }
  91.     /**
  92.      * 提供精确的乘法运算
  93.      *
  94.      * @param v1 被乘数
  95.      * @param v2 乘数
  96.      * @return 两个参数的积
  97.      */
  98.     public static double mul(double v1, double v2) {
  99.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  100.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  101.         return b1.multiply(b2).doubleValue();
  102.     }
  103.     /**
  104.      * 提供精确的乘法运算
  105.      *
  106.      * @param v1 被乘数
  107.      * @param v2 乘数
  108.      * @return 两个参数的积
  109.      */
  110.     public static BigDecimal mul(String v1, String v2) {
  111.         BigDecimal b1 = new BigDecimal(v1);
  112.         BigDecimal b2 = new BigDecimal(v2);
  113.         return b1.multiply(b2);
  114.     }
  115.     /**
  116.      * 提供精确的乘法运算
  117.      *
  118.      * @param v1    被乘数
  119.      * @param v2    乘数
  120.      * @param scale 保留scale 位小数
  121.      * @return 两个参数的积
  122.      */
  123.     public static double mul(double v1, double v2, int scale) {
  124.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  125.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  126.         return round(b1.multiply(b2).doubleValue(), scale);
  127.     }
  128.     /**
  129.      * 提供精确的乘法运算
  130.      *
  131.      * @param v1    被乘数
  132.      * @param v2    乘数
  133.      * @param scale 保留scale 位小数
  134.      * @return 两个参数的积
  135.      */
  136.     public static String mul(String v1, String v2, int scale) {
  137.         if (scale < 0) {
  138.             throw new IllegalArgumentException(
  139.                     "The scale must be a positive integer or zero");
  140.         }
  141.         BigDecimal b1 = new BigDecimal(v1);
  142.         BigDecimal b2 = new BigDecimal(v2);
  143.         return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  144.     }
  145.     /**
  146.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
  147.      * 小数点以后10位，以后的数字四舍五入
  148.      *
  149.      * @param v1 被除数
  150.      * @param v2 除数
  151.      * @return 两个参数的商
  152.      */
  153.     public static double div(double v1, double v2) {
  154.         return div(v1, v2, DEF_DIV_SCALE);
  155.     }
  156.     /**
  157.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
  158.      * 定精度，以后的数字四舍五入
  159.      *
  160.      * @param v1    被除数
  161.      * @param v2    除数
  162.      * @param scale 表示表示需要精确到小数点以后几位。
  163.      * @return 两个参数的商
  164.      */
  165.     public static double div(double v1, double v2, int scale) {
  166.         if (scale < 0) {
  167.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
  168.         }
  169.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  170.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  171.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  172.     }
  173.     /**
  174.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
  175.      * 定精度，以后的数字四舍五入
  176.      *
  177.      * @param v1    被除数
  178.      * @param v2    除数
  179.      * @param scale 表示需要精确到小数点以后几位
  180.      * @return 两个参数的商
  181.      */
  182.     public static String div(String v1, String v2, int scale) {
  183.         if (scale < 0) {
  184.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
  185.         }
  186.         BigDecimal b1 = new BigDecimal(v1);
  187.         BigDecimal b2 = new BigDecimal(v1);
  188.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
  189.     }
  190.     /**
  191.      * 提供精确的小数位四舍五入处理
  192.      *
  193.      * @param v     需要四舍五入的数字
  194.      * @param scale 小数点后保留几位
  195.      * @return 四舍五入后的结果
  196.      */
  197.     public static double round(double v, int scale) {
  198.         if (scale < 0) {
  199.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
  200.         }
  201.         BigDecimal b = new BigDecimal(Double.toString(v));
  202.         return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  203.     }
  204.     /**
  205.      * 提供精确的小数位四舍五入处理
  206.      *
  207.      * @param v     需要四舍五入的数字
  208.      * @param scale 小数点后保留几位
  209.      * @return 四舍五入后的结果
  210.      */
  211.     public static String round(String v, int scale) {
  212.         if (scale < 0) {
  213.             throw new IllegalArgumentException(
  214.                     "The scale must be a positive integer or zero");
  215.         }
  216.         BigDecimal b = new BigDecimal(v);
  217.         return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  218.     }
  219.     /**
  220.      * 取余数
  221.      *
  222.      * @param v1    被除数
  223.      * @param v2    除数
  224.      * @param scale 小数点后保留几位
  225.      * @return 余数
  226.      */
  227.     public static String remainder(String v1, String v2, int scale) {
  228.         if (scale < 0) {
  229.             throw new IllegalArgumentException(
  230.                     "The scale must be a positive integer or zero");
  231.         }
  232.         BigDecimal b1 = new BigDecimal(v1);
  233.         BigDecimal b2 = new BigDecimal(v2);
  234.         return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  235.     }
  236.     /**
  237.      * 取余数  BigDecimal
  238.      *
  239.      * @param v1    被除数
  240.      * @param v2    除数
  241.      * @param scale 小数点后保留几位
  242.      * @return 余数
  243.      */
  244.     public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
  245.         if (scale < 0) {
  246.             throw new IllegalArgumentException(
  247.                     "The scale must be a positive integer or zero");
  248.         }
  249.         return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
  250.     }
  251.     /**
  252.      * 比较大小
  253.      *
  254.      * @param v1 被比较数
  255.      * @param v2 比较数
  256.      * @return 如果v1 大于v2 则 返回true 否则false
  257.      */
  258.     public static boolean compare(String v1, String v2) {
  259.         BigDecimal b1 = new BigDecimal(v1);
  260.         BigDecimal b2 = new BigDecimal(v2);
  261.         int bj = b1.compareTo(b2);
  262.         boolean res;
  263.         if (bj > 0)
  264.             res = true;
  265.         else
  266.             res = false;
  267.         return res;
  268.     }
  269. }