我们都知道浮点型变量在进行计算的时候会出现丢失精度的问题。

    Java中float的精度为6-7位有效数字。double的精度为15-16位。

    1. add(BigDecimal)       BigDecimal对象中的值相加，然后返回这个对象。 
    2. subtract(BigDecimal)  BigDecimal对象中的值相减，然后返回这个对象。
    3. multiply(BigDecimal)  BigDecimal对象中的值相乘，然后返回这个对象。
    4. divide(BigDecimal)    BigDecimal对象中的值相除，然后返回这个对象。
    5. toString()            将BigDecimal对象的数值转换成字符串。
    6. doubleValue()         将BigDecimal对象中的值以双精度数返回。
    7. floatValue()          将BigDecimal对象中的值以单精度数返回。
    8. longValue()           将BigDecimal对象中的值以长整数返回。
    9. intValue()            将BigDecimal对象中的值以整数返回。

    一般使用BigDecimal来解决商业运算上丢失精度的问题的时候，声明BigDecimal对象的时候一定要使用它构造参数为String的类型的构造器。

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