解决精度损失问题

package com.tapi.esb.common.rule.logic;

import java.math.BigDecimal;

/**
 * TOPMathUtil
 * @author lubin
 *
 */
public class MathUtil {

    /**
     * 两个double相加，解决精度损失问题
     * @param a
     * @param b
     * @return a+b
     */
    public static double doubleAdd(double a,double b){
        BigDecimal A = new BigDecimal(Double.toString(a));
        BigDecimal B = new BigDecimal(Double.toString(b));
        double C = A.add(B).doubleValue();
        return C;
    }

    /**
     * 若干个double相加，，解决精度损失问题
     * @param a
     * @param args
     * @return a+b+c+.....
     */
    public static double doubleAdd(double a,double ...args){
        double sum=a;
        for (double d : args) {
            sum=doubleAdd(sum,d);
        }       
        return sum; 
    }

    /**
     * 两个double相减，解决精度损失问题
     * @param a
     * @param b
     * @return a-b
     */
    public static double doubleSubtract(double a,double b){
        BigDecimal A = new BigDecimal(Double.toString(a));
        BigDecimal B = new BigDecimal(Double.toString(b));
        double C = A.subtract(B).doubleValue();
        return C;
    }

    /**
     * 若干个double相减，，解决精度损失问题
     * @param a
     * @param args
     * @return a-b-c-.....
     */
    public static double doubleSubtract(double a,double ...args){
        double sum=a;
        for (double d : args) {
            sum=doubleSubtract(sum,d);
        }       
        return sum; 
    }

    /**
     * 两个double相乘，解决精度损失问题
     * @param a
     * @param b
     * @return a*b
     */
    public static double doubleMultiply(double a,double b){
        BigDecimal A = new BigDecimal(Double.toString(a));
        BigDecimal B = new BigDecimal(Double.toString(b));
        double C = A.multiply(B).doubleValue();
        return C;
    }

    /**
     * 若干个double相乘，，解决精度损失问题
     * @param a
     * @param args
     * @return a*b*c*...
     */
    public static double doubleMultiply(double a,double ...args){
        double sum=a;
        for (double d : args) {
            sum=doubleMultiply(sum,d);
        }       
        return sum;
    }

    /**
     * 两个double相除法，解决精度损失问题
     * @param a
     * @param b
     * @return a/b
     */
    public static double doubleDivide(double a,double b){
        BigDecimal A = new BigDecimal(Double.toString(a));
        BigDecimal B = new BigDecimal(Double.toString(b));
        double C = A.divide(B).doubleValue();
        return C;
    }

    /**
     * 若干个double相除，，解决精度损失问题
     * @param a
     * @param args
     * @return a/b/c/...
     */
    public static double doubleDivide(double a,double ...args){
        double sum=a;
        for (double d : args) {
            sum=doubleDivide(sum,d);
        }       
        return sum;
    }
}