精确计算工具类，提供加减乘除的计算代码,Java代码库,德仔网

代码语言
代码分类
【Java】精确计算工具类，提供加减乘除的计算
作者:玉云 / 发布于2016/7/4/ 1021
package com.system.util;

import java.math.BigDecimal;

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

    
    /**
     * BigDecimal大小比较
     * 
     * @param a
     * @param b
     * @return 返回1， 表示a大于b <br/> 
     *                  返回0 ，表示a等于b <br/> 
     *         返回-1，表示a小于b
     * @author jqlin
     */
    public static int compareTo(BigDecimal a, BigDecimal b){
        return a.compareTo(b);
    }
    
    /**
     * 累加运算 
     * 
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal add(int scale, BigDecimal... vals) {
        if(vals == null || vals.length <= 0){
            return null;
        }
        
        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
     */
    public static int add(int... vals) {
        if(vals == null || vals.length <= 0){
            return 0;
        }
        
        int sum = 0;
        for(int val : vals){
            sum = sum + val;
        }
        
        return sum;
    }
    
    /**
     * 累加运算 
     * 
     * @param scale
     * @param vals 小数点后保留几位
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double add(int scale, double... vals) {
        if(vals == null || vals.length <= 0){
            return 0;
        }
        
        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
     */
    public static float add(int scale, float... vals) {
        if(vals == null || vals.length <= 0){
            return 0;
        }
        
        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
     */
    public static 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
     */
    public static BigDecimal add(BigDecimal a, BigDecimal b) {
        return  add(a, b, SCALE);
    }
    
    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double 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
     */
    public static double 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
     */
    public static 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
     */
    public static BigDecimal subtract(BigDecimal a, BigDecimal b) {
        return subtract(a, b, SCALE);
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double 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
     */
    public static double 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
     */
    public static 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
     */
    public static BigDecimal multiply(BigDecimal a, BigDecimal b) {
        return multiply(a, b, SCALE); 
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double 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
     */
    public static double multiply(double a, double b) {
        return multiply(a, b, SCALE); 
    }
    
    
    /**
     * 除法运算 
     * 
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果 
     * @author jqlin
     */
    public static 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
     */
    public static BigDecimal divide(BigDecimal a, BigDecimal b) {
        return divide(a, b, SCALE);
    }
    
    /**
     * 除法运算 
     * 
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果 
     * @author jqlin
     */
    public static double 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
     */
    public static double divide(double a, double b) {
        return divide(a, b, SCALE);
    }
  
}
试试其它关键字
　精确计算　
同语言下
可能有用的
玉云贡献的其它代码(22)