java 浮点数 高精度计算

    1. import java.math.BigDecimal;
    3. public class BigDecimalUtil {
    4.     //默认除法运算精度
    5.     private static final int DEF_DIV_SCALE = 10; //这个类不能实例化
    7.     private BigDecimalUtil() {
    9.     }
    11.     /**
    12.      * 提供精确的加法运算。
    13.      *
    14.      * @param v1 被加数
    15.      * @param v2 加数
    16.      * @return 两个参数的和
    17.      * 返回double类型数据
    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.     }
    25.     /**
    26.      * 提供精确的加法运算。
    27.      *
    28.      * @param v1 被加数
    29.      * @param v2 加数
    30.      * @return 两个参数的和
    31.      * 返回字符串类型数据
    32.      */
    33.     public static String addToString(double v1, double v2) {
    34.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    35.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    36.         return b1.add(b2).toString();
    37.     }
    39.     /**
    40.      * 提供精确的减法运算。
    41.      *
    42.      * @param v1 被减数
    43.      * @param v2 减数
    44.      * @return 两个参数的差
    45.      * 返回double类型数据
    46.      */
    47.     public static double sub(double v1, double v2) {
    48.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    49.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    50.         return b1.subtract(b2).doubleValue();
    51.     }
    53.     /**
    54.      * 提供精确的减法运算。
    55.      *
    56.      * @param v1 被减数
    57.      * @param v2 减数
    58.      * @return 两个参数的差
    59.      * 返回字符串类型数据
    60.      */
    61.     public static String subString(double v1, double v2) {
    62.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    63.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    64.         return b1.subtract(b2).toString();
    65.     }
    67.     /**
    68.      * 提供精确的乘法运算。
    69.      *
    70.      * @param v1 被乘数
    71.      * @param v2 乘数
    72.      * @return 两个参数的积
    73.      * 返回double类型数据
    74.      */
    75.     public static double mul(double v1, double v2) {
    76.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    77.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    78.         return b1.multiply(b2).doubleValue();
    79.     }
    81.     /**
    82.      * 提供精确的乘法运算。
    83.      *
    84.      * @param v1    被乘数
    85.      * @param v2    乘数
    86.      * @param scale 表示表示需要保留小数点后几位
    87.      * @return 两个参数的积
    88.      * 返回double类型数据
    89.      */
    90.     public static double mulByScale(double v1, double v2, int scale) {
    91.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    92.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    93.         return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    94.     }
    96.     /**
    97.      * 提供精确的乘法运算。
    98.      *
    99.      * @param v1    被乘数
    100.      * @param v2    乘数
    101.      * @param scale 表示表示需要保留小数点后几位
    102.      * @return 两个参数的积
    103.      * 返回字符串类型数据
    104.      */
    105.     public static String mulByScaleToString(double v1, double v2, int scale) {
    106.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    107.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    108.         return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    109.     }
    111.     /**
    112.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
    113.      * 小数点以后10位，以后的数字四舍五入。
    114.      *
    115.      * @param v1 被除数
    116.      * @param v2 除数
    117.      * @return 两个参数的商
    118.      */
    119.     public static double div(double v1, double v2) {
    120.         return div(v1, v2, DEF_DIV_SCALE);
    121.     }
    123.     /**
    124.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
    125.      * 定精度，以后的数字四舍五入。
    126.      *
    127.      * @param v1    被除数
    128.      * @param v2    除数
    129.      * @param scale 表示表示需要精确到小数点以后几位。
    130.      * @return 两个参数的商
    131.      */
    132.     public static double div(double v1, double v2, int scale) {
    133.         if (scale < 0) {
    134.             throw new IllegalArgumentException(
    135.                     "The scale must be a positive integer or zero");
    136.         }
    137.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
    138.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
    139.         return b2.divide(b1, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    140.     }
    142.     /**
    143.      * 提供精确的小数位四舍五入处理。
    144.      *
    145.      * @param v     需要四舍五入的数字
    146.      * @param scale 小数点后保留几位
    147.      * @return 四舍五入后的结果
    148.      */
    149.     public static double round(double v, int scale) {
    150.         if (scale < 0) {
    151.             throw new IllegalArgumentException(
    152.                     "The scale must be a positive integer or zero");
    153.         }
    154.         BigDecimal b = new BigDecimal(Double.toString(v));
    155.         BigDecimal one = new BigDecimal("1");
    156.         return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    157.     }
    158. }