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

    工具类2

    1. import java.math.BigDecimal;
    2. import java.math.RoundingMode;
    3. import java.text.NumberFormat;
    5. /**
    6.  * @Description:全局 BigDecimal 工具类
    7.  * @Author: tarzan
    8.  * @Date: 2021/09/31 9:06
    9.  */
    10. public class SmartBigDecimalUtil {
    12.     /**
    13.      * 价格类型 保留小数点 2
    14.      */
    15.     public static final int PRICE_DECIMAL_POINT = 2;
    17.     /**
    18.      * 价格类型 保留小数点 6
    19.      */
    20.     public static final int SIX_PRICE_DECIMAL_POINT = 6;
    22.     /**
    23.      * 重量类型保留小数点 3
    24.      */
    25.     public static final int WEIGHT_DECIMAL_POINT = 3;
    27.     /**
    28.      * 金额相关计算方法：四舍五入 保留2位小数点
    29.      */
    30.     public static class Amount {
    32.         public static BigDecimal add(BigDecimal num1, BigDecimal num2) {
    33.             return setScale(num1.add(num2), PRICE_DECIMAL_POINT);
    34.         }
    35.         public static BigDecimal multiply(BigDecimal num1, BigDecimal num2) {
    36.             return setScale(num1.multiply(num2), PRICE_DECIMAL_POINT);
    37.         }
    38.         public static BigDecimal subtract(BigDecimal num1, BigDecimal num2) {
    39.             return setScale(num1.subtract(num2), PRICE_DECIMAL_POINT);
    40.         }
    41.         public static BigDecimal divide(BigDecimal num1, BigDecimal num2) {
    42.             return setScale(num1.divide(num2, RoundingMode.HALF_UP), PRICE_DECIMAL_POINT);
    43.         }
    44.     }
    46.     /**
    47.      * 金额相关计算方法：四舍五入 保留2位小数点
    48.      */
    49.     public static class AmountSix {
    51.         public static BigDecimal add(BigDecimal num1, BigDecimal num2) {
    52.             return setScale(num1.add(num2), SIX_PRICE_DECIMAL_POINT);
    53.         }
    54.         public static BigDecimal multiply(BigDecimal num1, BigDecimal num2) {
    55.             return setScale(num1.multiply(num2), SIX_PRICE_DECIMAL_POINT);
    56.         }
    57.         public static BigDecimal subtract(BigDecimal num1, BigDecimal num2) {
    58.             return setScale(num1.subtract(num2), SIX_PRICE_DECIMAL_POINT);
    59.         }
    60.         public static BigDecimal divide(BigDecimal num1, BigDecimal num2) {
    61.             return num1.divide(num2, PRICE_DECIMAL_POINT, RoundingMode.HALF_UP);
    62.         }
    63.     }
    65.     /**
    66.      * 重量相关计算方法：四舍五入 保留3位小数点
    67.      */
    68.     public static class Weight {
    70.         public static BigDecimal add(BigDecimal num1, BigDecimal num2) {
    71.             return setScale(num1.add(num2), WEIGHT_DECIMAL_POINT);
    72.         }
    73.         public static BigDecimal multiply(BigDecimal num1, BigDecimal num2) {
    74.             return setScale(num1.multiply(num2), WEIGHT_DECIMAL_POINT);
    75.         }
    76.         public static BigDecimal subtract(BigDecimal num1, BigDecimal num2) {
    77.             return setScale(num1.subtract(num2), WEIGHT_DECIMAL_POINT);
    78.         }
    79.         public static BigDecimal divide(BigDecimal num1, BigDecimal num2) {
    80.             return num1.divide(num2, WEIGHT_DECIMAL_POINT, RoundingMode.HALF_UP);
    81.         }
    82.     }
    84.     /**
    85.      * BigDecimal 加法 num1 + num2
    86.      * 未做非空校验
    87.      *
    88.      * @param num1
    89.      * @param num2
    90.      * @param point 请使用BigDecimalUtils.PRICE_DECIMAL_POINT | BigDecimalUtils.WEIGHT_DECIMAL_POINT
    91.      * @return BigDecimal
    92.      */
    93.     public static BigDecimal add(BigDecimal num1, BigDecimal num2, int point) {
    94.         return setScale(num1.add(num2), point);
    95.     }
    97.     /**
    98.      * BigDecimal 乘法 num1 x num2
    99.      * 未做非空校验
    100.      *
    101.      * @param num1
    102.      * @param num2
    103.      * @param point 请使用BigDecimalUtils.PRICE_DECIMAL_POINT | BigDecimalUtils.WEIGHT_DECIMAL_POINT
    104.      * @return BigDecimal
    105.      */
    106.     public static BigDecimal multiply(BigDecimal num1, BigDecimal num2, int point) {
    107.         return setScale(num1.multiply(num2), point);
    108.     }
    110.     /**
    111.      * BigDecimal 减法 num1 - num2
    112.      * 未做非空校验
    113.      *
    114.      * @param num1
    115.      * @param num2
    116.      * @param point 请使用BigDecimalUtils.PRICE_DECIMAL_POINT | BigDecimalUtils.WEIGHT_DECIMAL_POINT
    117.      * @return BigDecimal
    118.      */
    119.     public static BigDecimal subtract(BigDecimal num1, BigDecimal num2, int point) {
    120.         return setScale(num1.subtract(num2), point);
    121.     }
    123.     /**
    124.      * BigDecimal 除法 num1/num2
    125.      * 未做非空校验
    126.      *
    127.      * @param num1
    128.      * @param num2
    129.      * @param point 请使用BigDecimalUtils.PRICE_DECIMAL_POINT | BigDecimalUtils.WEIGHT_DECIMAL_POINT
    130.      * @return BigDecimal
    131.      */
    132.     public static BigDecimal divide(BigDecimal num1, BigDecimal num2, int point) {
    133.         return num1.divide(num2, point, RoundingMode.HALF_UP);
    134.     }
    136.     /**
    137.      * 设置小数点类型为 四舍五入
    138.      *
    139.      * @param num
    140.      * @param point
    141.      * @return BigDecimal
    142.      */
    143.     public static BigDecimal setScale(BigDecimal num, int point) {
    144.         return num.setScale(point, RoundingMode.HALF_UP);
    145.     }
    147.     /**
    148.      * 比较 num1 是否大于 num2
    149.      *
    150.      * @param num1
    151.      * @param num2
    152.      * @return boolean
    153.      */
    154.     public static boolean isGreaterThan(BigDecimal num1, BigDecimal num2) {
    155.         return num1.compareTo(num2) == 1;
    156.     }
    158.     /**
    159.      * 比较 num1 是否大于等于 num2
    160.      *
    161.      * @param num1
    162.      * @param num2
    163.      * @return boolean
    164.      */
    165.     public static boolean isGreaterOrEqual(BigDecimal num1, BigDecimal num2) {
    166.         return isGreaterThan(num1, num2) || equals(num1, num2);
    167.     }
    169.     /**
    170.      * 比较 num1 是否小于 num2
    171.      *
    172.      * @param num1
    173.      * @param num2
    174.      * @return boolean
    175.      */
    176.     public static boolean isLessThan(BigDecimal num1, BigDecimal num2) {
    177.         return num1.compareTo(num2) == - 1;
    178.     }
    180.     /**
    181.      * 比较 num1 是否小于等于 num2
    182.      *
    183.      * @param num1
    184.      * @param num2
    185.      * @return boolean
    186.      */
    187.     public static boolean isLessOrEqual(BigDecimal num1, BigDecimal num2) {
    188.         return isLessThan(num1, num2) || equals(num1, num2);
    189.     }
    191.     /**
    192.      * 比较 num1 是否等于 num2
    193.      *
    194.      * @param num1
    195.      * @param num2
    196.      * @return
    197.      */
    198.     public static boolean equals(BigDecimal num1, BigDecimal num2) {
    199.         return num1.compareTo(num2) == 0;
    200.     }
    202.     /**
    203.      * 计算 num1 / num2 的百分比
    204.      *
    205.      * @param num1
    206.      * @param num2
    207.      * @return String
    208.      */
    209.     public static String getPercentage(BigDecimal num1, BigDecimal num2) {
    210.         BigDecimal result = num1.divide(num2, 4, RoundingMode.HALF_UP);
    211.         NumberFormat percent = NumberFormat.getPercentInstance();
    212.         percent.setMaximumFractionDigits(2);
    213.         return percent.format(result.doubleValue());
    214.     }
    216.     /**
    217.      * 计算 num1 / num2 的百分比
    218.      *
    219.      * @param num1
    220.      * @param num2
    221.      * @param point 保留几位小数
    222.      * @return String
    223.      */
    224.     public static BigDecimal bigDecimalPercent(Integer num1, Integer num2, int point) {
    225.         if (num1 == null || num2 == null) {
    226.             return BigDecimal.ZERO;
    227.         }
    228.         if (num2.equals(Integer.valueOf(0))) {
    229.             return BigDecimal.ZERO;
    230.         }
    231.         BigDecimal bigDecimalNum1 = new BigDecimal(num1);
    232.         BigDecimal bigDecimalNum2 = new BigDecimal(num2);
    233.         return bigDecimalPercent(bigDecimalNum1, bigDecimalNum2, point);
    234.     }
    236.     /**
    237.      * 计算 num1 / num2 的百分比
    238.      *
    239.      * @param num1
    240.      * @param num2
    241.      * @param point 保留几位小数
    242.      * @return String
    243.      */
    244.     public static BigDecimal bigDecimalPercent(BigDecimal num1, BigDecimal num2, int point) {
    245.         if (num1 == null || num2 == null) {
    246.             return BigDecimal.ZERO;
    247.         }
    248.         if (equals(BigDecimal.ZERO, num2)) {
    249.             return BigDecimal.ZERO;
    250.         }
    251.         BigDecimal percent = num1.divide(num2, point + 2, RoundingMode.HALF_UP);
    252.         BigDecimal percent100 = percent.multiply(new BigDecimal(100)).setScale(point);
    253.         return percent100;
    254.     }
    256.     /**
    257.      * 判断num是否为空 或者 零
    258.      *
    259.      * @param num
    260.      * @return String
    261.      */
    262.     public static Boolean isEmpty(BigDecimal num) {
    263.         return null == num || equals(BigDecimal.ZERO, num);
    264.     }
    266.     /**
    267.      * 判断num是否 不等于null 并且不等于零
    268.      *
    269.      * @param num
    270.      * @return String
    271.      */
    272.     public static Boolean isNotEmpty(BigDecimal num) {
    273.         return ! isEmpty(num);
    274.     }
    276.     /**
    277.      * 转换为万
    278.      *
    279.      * @param num
    280.      * @param point
    281.      * @return
    282.      */
    283.     public static BigDecimal convertTenThousand(BigDecimal num, int point) {
    284.         BigDecimal decimal = num.divide(new BigDecimal(10000), point, RoundingMode.HALF_UP);
    285.         return decimal;
    286.     }
    288.     /**
    289.      * 转换为负数
    290.      *
    291.      * @param num
    292.      * @return
    293.      */
    294.     public static BigDecimal convertToMinusNumber(BigDecimal num) {
    295.         if (isLessOrEqual(num, BigDecimal.ZERO)) {
    296.             return num;
    297.         }
    298.         return BigDecimal.ZERO.subtract(num);
    299.     }
    301. }

    工具类3

    2. /**
    3.  * @author wuke
    4.  * @date 2022年03月22日 11:37
    5.  */
    6. public class BigDecimalUtil {
    8.     /**
    9.      * 对BigDecimal求2次平方根，精度无损失。
    10.      */
    11.     public static BigDecimal sqrt(BigDecimal value) {
    12.         BigDecimal val = BigDecimal.valueOf(Math.sqrt(value.doubleValue()));
    13.         return val.add(BigDecimal.valueOf(value.subtract(val.multiply(val)).doubleValue() / (val.doubleValue() * 2.0)));
    14.     }
    16.     /**
    17.      * 对BigDecimal求平方根，结果四舍五入
    18.      *
    19.      * @param scale 几次方
    20.      * @return java.math.BigDecimal
    21.      * @author wuke
    22.      * @date 2022/3/22 14:06
    23.      */
    24.     public static BigDecimal sqrt(BigDecimal value, int scale) {
    25.         if (value.compareTo(BigDecimal.ZERO) == 0) {
    26.             return new BigDecimal(0);
    27.         }
    28.         BigDecimal num2 = BigDecimal.valueOf(2);
    29.         int precision = 100;
    30.         BigDecimal deviation = value;
    31.         int cnt = 0;
    32.         while (cnt < precision) {
    33.             deviation = (deviation.add(value.divide(deviation, 100, RoundingMode.HALF_UP))).divide(num2, 100, RoundingMode.HALF_UP);
    34.             cnt++;
    35.         }
    36.         deviation = deviation.setScale(scale, RoundingMode.HALF_UP);
    37.         return deviation;
    38.     }
    39. }