精确计算工具类，提供加减乘除的计算

package com.system.util;

import java.math.BigDecimal;

/**
 * 精确计算工具类，提供加减乘除的计算
 *
 * @author jqlin
 */publicclass CompuUtils {
    /**小数点后保留的位数*/public final staticint SCALE = 5;
    /** 0 */public final staticint ZERO = 0;

    
    /**
     * BigDecimal大小比较
     * 
     * @param a
     * @param b
     * @return 返回1， 表示a大于b <br/> 
     *                  返回0 ，表示a等于b <br/> 
     *         返回-1，表示a小于b
     * @author jqlin
     */publicstaticint compareTo(BigDecimal a, BigDecimal b){
        return a.compareTo(b);
    }
    
    /**
     * 累加运算 
     * 
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal add(int scale, BigDecimal... vals) {
        if(vals == null || vals.length <= 0){
            returnnull;
        }
        
        BigDecimal sum = new BigDecimal("0");
        for(BigDecimal val : vals){
            sum = sum.add(val);
        }
        
        return sum.setScale(scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 累加运算 
     * 
     * @param vals
     * @return
     * @author jqlin
     */publicstaticint add(int... vals) {
        if(vals == null || vals.length <= 0){
            return0;
        }
        
        int sum = 0;
        for(int val : vals){
            sum = sum + val;
        }
        
        return sum;
    }
    
    /**
     * 累加运算 
     * 
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble add(int scale, double... vals) {
        if(vals == null || vals.length <= 0){
            return0;
        }
        
        BigDecimal sum = new BigDecimal("0");
        for(double val : vals){
            sum = sum.add(new BigDecimal(val));
        }
        
        return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    
    /**
     * 累加运算 
     * 
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticfloat add(int scale, float... vals) {
        if(vals == null || vals.length <= 0){
            return0;
        }
        
        BigDecimal sum = new BigDecimal("0");
        for(float val : vals){
            sum = sum.add(new BigDecimal(val));
        }
        
        return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).floatValue();
    }

    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal add(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.add(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal add(BigDecimal a, BigDecimal b) {
        return  add(a, b, SCALE);
    }
    
    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble add(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return add(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }
    
    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble add(double a, double b) {
        return add(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal subtract(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.subtract(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal subtract(BigDecimal a, BigDecimal b) {
        return subtract(a, b, SCALE);
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble subtract(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return subtract(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble subtract(double a, double b) {
        return subtract(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal multiply(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.multiply(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal multiply(BigDecimal a, BigDecimal b) {
        return multiply(a, b, SCALE); 
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble multiply(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return multiply(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @return 四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble multiply(double a, double b) {
        return multiply(a, b, SCALE); 
    }
    
    
    /**
     * 除法运算 
     * 
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal divide(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return a.divide(b, scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 除法运算，默认保留5位小数点
     * 
     * @param a 被除数
     * @param b 除数
     * @return    四舍五入后的结果 
     * @author jqlin
     */publicstatic BigDecimal divide(BigDecimal a, BigDecimal b) {
        return divide(a, b, SCALE);
    }
    
    /**
     * 除法运算 
     * 
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble divide(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return divide(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }
    
    /**
     * 除法运算，默认保留5位小数点
     * 
     * @param a 被除数
     * @param b 除数
     * @return    四舍五入后的结果 
     * @author jqlin
     */publicstaticdouble divide(double a, double b) {
        return divide(a, b, SCALE);
    }