• 告警：线上慎用 BigDecimal ，坑的差点被开了

    Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。

    一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。

    BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

    BigDecimal常用构造函数

    1、常用构造函数

    • BigDecimal(int)

    创建一个具有参数所指定整数值的对象

    • BigDecimal(double)

    创建一个具有参数所指定双精度值的对象

    • BigDecimal(long)

    创建一个具有参数所指定长整数值的对象

    • BigDecimal(String)

    创建一个具有参数所指定以字符串表示的数值的对象

    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中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

    2）String 构造方法是完全可预知的：写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言， 通常建议优先使用String构造方法。

    3）当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。

    BigDecimal常用方法详解

    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对象中的值转换成整数

    2、BigDecimal大小比较

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

    int a = bigdemical.compareTo(bigdemical2)

    返回结果分析：

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

    举例：a大于等于b

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

    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.  
    5. BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
    6. BigDecimal interestRate = new BigDecimal("0.008"); //利率   
    7. BigDecimal interest = loanAmount.multiply(interestRate); //相乘
    8.  
    9. System.out.println("贷款金额:\t" + currency.format(loanAmount)); 
    10. System.out.println("利率:\t" + percent.format(interestRate)); 
    11. System.out.println("利息:\t" + currency.format(interest)); 

    结果：

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

    BigDecimal格式化保留2为小数，不足则补0：

    1. public class NumberFormat {
    2.  
    3.     public static void main(String[] s){
    4.         System.out.println(formatToNumber(new BigDecimal("3.435")));
    5.         System.out.println(formatToNumber(new BigDecimal(0)));
    6.         System.out.println(formatToNumber(new BigDecimal("0.00")));
    7.         System.out.println(formatToNumber(new BigDecimal("0.001")));
    8.         System.out.println(formatToNumber(new BigDecimal("0.006")));
    9.         System.out.println(formatToNumber(new BigDecimal("0.206")));
    10.     }
    11.     /**
    12.      * @desc 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。
    13.      * 2.传入的参数等于0，则直接返回字符串"0.00"
    14.      * 3.大于1的小数，直接格式化返回字符串
    15.      * @param obj传入的小数
    16.      * @return
    17.      */
    18.     public static String formatToNumber(BigDecimal obj) {
    19.         DecimalFormat df = new DecimalFormat("#.00");
    20.         if(obj.compareTo(BigDecimal.ZERO)==0) {
    21.             return "0.00";
    22.         }else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){
    23.             return "0"+df.format(obj).toString();
    24.         }else {
    25.             return df.format(obj).toString();
    26.         }
    27.     }
    28. }

    结果为：

    1. 3.44
    2. 0.00
    3. 0.00
    4. 0.00
    5. 0.01
    6. 0.21

    BigDecimal常见异常

    除法的时候出现异常

    java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result

    原因分析：

    通过BigDecimal的divide方法进行除法时当不整除，出现无限循环小数时，就会抛异常：java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

    解决方法：

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

    BigDecimal总结

    1、总结

    在需要精确的小数计算时再使用BigDecimal，BigDecimal的性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。 尽量使用参数类型为String的构造函数。

    BigDecimal都是不可变的（immutable）的， 在进行每一次四则运算时，都会产生一个新的对象 ，所以在做加减乘除运算时要记得要保存操作后的值。

    2、工具类推荐

    1. package com.vivo.ars.util;
    2. import java.math.BigDecimal;
    3.  
    4. /**
    5.  * 用于高精确处理常用的数学运算
    6.  */
    7. public class ArithmeticUtils {
    8.     //默认除法运算精度
    9.     private static final int DEF_DIV_SCALE = 10;
    10.  
    11.     /**
    12.      * 提供精确的加法运算
    13.      *
    14.      * @param v1 被加数
    15.      * @param v2 加数
    16.      * @return 两个参数的和
    17.      */
    18.  
    19.     public static double add(double v1, double v2) {
    20.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    21.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    22.         return b1.add(b2).doubleValue();
    23.     }
    24.  
    25.     /**
    26.      * 提供精确的加法运算
    27.      *
    28.      * @param v1 被加数
    29.      * @param v2 加数
    30.      * @return 两个参数的和
    31.      */
    32.     public static BigDecimal add(String v1, String v2) {
    33.         BigDecimal b1 = new BigDecimal(v1);
    34.         BigDecimal b2 = new BigDecimal(v2);
    35.         return b1.add(b2);
    36.     }
    37.  
    38.     /**
    39.      * 提供精确的加法运算
    40.      *
    41.      * @param v1    被加数
    42.      * @param v2    加数
    43.      * @param scale 保留scale 位小数
    44.      * @return 两个参数的和
    45.      */
    46.     public static String add(String v1, String v2, int scale) {
    47.         if (scale < 0) {
    48.             throw new IllegalArgumentException(
    49.                     "The scale must be a positive integer or zero");
    50.         }
    51.         BigDecimal b1 = new BigDecimal(v1);
    52.         BigDecimal b2 = new BigDecimal(v2);
    53.         return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    54.     }
    55.  
    56.     /**
    57.      * 提供精确的减法运算
    58.      *
    59.      * @param v1 被减数
    60.      * @param v2 减数
    61.      * @return 两个参数的差
    62.      */
    63.     public static double sub(double v1, double v2) {
    64.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    65.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    66.         return b1.subtract(b2).doubleValue();
    67.     }
    68.  
    69.     /**
    70.      * 提供精确的减法运算。
    71.      *
    72.      * @param v1 被减数
    73.      * @param v2 减数
    74.      * @return 两个参数的差
    75.      */
    76.     public static BigDecimal sub(String v1, String v2) {
    77.         BigDecimal b1 = new BigDecimal(v1);
    78.         BigDecimal b2 = new BigDecimal(v2);
    79.         return b1.subtract(b2);
    80.     }
    81.  
    82.     /**
    83.      * 提供精确的减法运算
    84.      *
    85.      * @param v1    被减数
    86.      * @param v2    减数
    87.      * @param scale 保留scale 位小数
    88.      * @return 两个参数的差
    89.      */
    90.     public static String sub(String v1, String v2, int scale) {
    91.         if (scale < 0) {
    92.             throw new IllegalArgumentException(
    93.                     "The scale must be a positive integer or zero");
    94.         }
    95.         BigDecimal b1 = new BigDecimal(v1);
    96.         BigDecimal b2 = new BigDecimal(v2);
    97.         return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    98.     }
    99.  
    100.     /**
    101.      * 提供精确的乘法运算
    102.      *
    103.      * @param v1 被乘数
    104.      * @param v2 乘数
    105.      * @return 两个参数的积
    106.      */
    107.     public static double mul(double v1, double v2) {
    108.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    109.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    110.         return b1.multiply(b2).doubleValue();
    111.     }
    112.  
    113.     /**
    114.      * 提供精确的乘法运算
    115.      *
    116.      * @param v1 被乘数
    117.      * @param v2 乘数
    118.      * @return 两个参数的积
    119.      */
    120.     public static BigDecimal mul(String v1, String v2) {
    121.         BigDecimal b1 = new BigDecimal(v1);
    122.         BigDecimal b2 = new BigDecimal(v2);
    123.         return b1.multiply(b2);
    124.     }
    125.  
    126.     /**
    127.      * 提供精确的乘法运算
    128.      *
    129.      * @param v1    被乘数
    130.      * @param v2    乘数
    131.      * @param scale 保留scale 位小数
    132.      * @return 两个参数的积
    133.      */
    134.     public static double mul(double v1, double v2, int scale) {
    135.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    136.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    137.         return round(b1.multiply(b2).doubleValue(), scale);
    138.     }
    139.  
    140.     /**
    141.      * 提供精确的乘法运算
    142.      *
    143.      * @param v1    被乘数
    144.      * @param v2    乘数
    145.      * @param scale 保留scale 位小数
    146.      * @return 两个参数的积
    147.      */
    148.     public static String mul(String v1, String v2, int scale) {
    149.         if (scale < 0) {
    150.             throw new IllegalArgumentException(
    151.                     "The scale must be a positive integer or zero");
    152.         }
    153.         BigDecimal b1 = new BigDecimal(v1);
    154.         BigDecimal b2 = new BigDecimal(v2);
    155.         return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    156.     }
    157.  
    158.     /**
    159.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
    160.      * 小数点以后10位，以后的数字四舍五入
    161.      *
    162.      * @param v1 被除数
    163.      * @param v2 除数
    164.      * @return 两个参数的商
    165.      */
    166.  
    167.     public static double div(double v1, double v2) {
    168.         return div(v1, v2, DEF_DIV_SCALE);
    169.     }
    170.  
    171.     /**
    172.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
    173.      * 定精度，以后的数字四舍五入
    174.      *
    175.      * @param v1    被除数
    176.      * @param v2    除数
    177.      * @param scale 表示表示需要精确到小数点以后几位。
    178.      * @return 两个参数的商
    179.      */
    180.     public static double div(double v1, double v2, int scale) {
    181.         if (scale < 0) {
    182.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
    183.         }
    184.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    185.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    186.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    187.     }
    188.  
    189.     /**
    190.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
    191.      * 定精度，以后的数字四舍五入
    192.      *
    193.      * @param v1    被除数
    194.      * @param v2    除数
    195.      * @param scale 表示需要精确到小数点以后几位
    196.      * @return 两个参数的商
    197.      */
    198.     public static String div(String v1, String v2, int scale) {
    199.         if (scale < 0) {
    200.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
    201.         }
    202.         BigDecimal b1 = new BigDecimal(v1);
    203.         BigDecimal b2 = new BigDecimal(v1);
    204.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    205.     }
    206.  
    207.     /**
    208.      * 提供精确的小数位四舍五入处理
    209.      *
    210.      * @param v     需要四舍五入的数字
    211.      * @param scale 小数点后保留几位
    212.      * @return 四舍五入后的结果
    213.      */
    214.     public static double round(double v, int scale) {
    215.         if (scale < 0) {
    216.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
    217.         }
    218.         BigDecimal b = new BigDecimal(Double.toString(v));
    219.         return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    220.     }
    221.  
    222.     /**
    223.      * 提供精确的小数位四舍五入处理
    224.      *
    225.      * @param v     需要四舍五入的数字
    226.      * @param scale 小数点后保留几位
    227.      * @return 四舍五入后的结果
    228.      */
    229.     public static String round(String v, int scale) {
    230.         if (scale < 0) {
    231.             throw new IllegalArgumentException(
    232.                     "The scale must be a positive integer or zero");
    233.         }
    234.         BigDecimal b = new BigDecimal(v);
    235.         return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    236.     }
    237.  
    238.     /**
    239.      * 取余数
    240.      *
    241.      * @param v1    被除数
    242.      * @param v2    除数
    243.      * @param scale 小数点后保留几位
    244.      * @return 余数
    245.      */
    246.     public static String remainder(String v1, String v2, int scale) {
    247.         if (scale < 0) {
    248.             throw new IllegalArgumentException(
    249.                     "The scale must be a positive integer or zero");
    250.         }
    251.         BigDecimal b1 = new BigDecimal(v1);
    252.         BigDecimal b2 = new BigDecimal(v2);
    253.         return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    254.     }
    255.  
    256.     /**
    257.      * 取余数  BigDecimal
    258.      *
    259.      * @param v1    被除数
    260.      * @param v2    除数
    261.      * @param scale 小数点后保留几位
    262.      * @return 余数
    263.      */
    264.     public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
    265.         if (scale < 0) {
    266.             throw new IllegalArgumentException(
    267.                     "The scale must be a positive integer or zero");
    268.         }
    269.         return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
    270.     }
    271.  
    272.     /**
    273.      * 比较大小
    274.      *
    275.      * @param v1 被比较数
    276.      * @param v2 比较数
    277.      * @return 如果v1 大于v2 则 返回true 否则false
    278.      */
    279.     public static boolean compare(String v1, String v2) {
    280.         BigDecimal b1 = new BigDecimal(v1);
    281.         BigDecimal b2 = new BigDecimal(v2);
    282.         int bj = b1.compareTo(b2);
    283.         boolean res;
    284.         if (bj > 0)
    285.             res = true;
    286.         else
    287.             res = false;
    288.         return res;
    289.     }
    290. }
  • 相关阅读:
    全栈项目【尚医通】预约挂号系统项目介绍
    如何让别人看不懂你的 JS 代码？把你当大佬！
    Kubernetes云原生实战02 对节点磁盘进行分区挂载
    java计算机毕业设计-旅游产品销售管理-演示录像2020源码+数据库+系统+lw文档+mybatis+运行部署
    每天一个数据分析题（三百九十二）- 多元线性回归
    排序算法：希尔排序
    CMMI是什么? 看完这篇你就懂了
    网安小贴士（4）哈希函数
    排序1:直接插入排序
    PDF Shaper Pro v12.8 全能PDF工具箱中文版
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/128145495