关于计算的工具类总结

package cn.common.utils;

import java.math.BigDecimal;

import org.apache.commons.lang3.math.NumberUtils;

import com.google.common.base.Optional;

/**
* @ClassName: DecimalCalculate
* @Description: 计算公式
* @author happiness
* @date 2018年8月25日 下午10:37:36
* @version V1.0 
*/
public class DecimalCalculate {
    //默认保留小数点位数
    private static int SCALE = 4;
    
    /**
     * String的加法运算封装
     * @param before
     * @param after
     * @return
     */
    public static BigDecimal safeAdd ( String before, String after ) {
        if ((!StringUtil.isNumeric(before)) || (!StringUtil.isNumeric(after)))
            return BigDecimal.ZERO;
        return NumberUtils.createBigDecimal(before)
                .add( NumberUtils.createBigDecimal(after));
    }
    
    /**
     * BigDecimal的加法运算封装
     * @param b1
     * @param bn
     * @return
     */
   public static BigDecimal safeAdd(BigDecimal b1, BigDecimal... bn) {
       if (null == b1) {
           b1 = BigDecimal.ZERO;
       }
       if (null != bn) {
           for (BigDecimal b : bn) {
               b1 = b1.add(null == b ? BigDecimal.ZERO : b);
           }
       }
       return b1;
   }
 
   /**
    * Integer加法运算的封装
    * @param b1   第一个数
    * @param bn   需要加的加法数组
    * @注 ： Optional  是属于com.google.common.base.Optional<T> 下面的class
    * @return
    */
   public static Integer safeAdd(Integer b1, Integer... bn) {
       if (null == b1) {
           b1 = 0;
       }
       Integer r = b1;
       if (null != bn) {
           for (Integer b : bn) {
               r += Optional.fromNullable(b).or(0);
           }
       }
       return r > 0 ? r : 0;
   }
 
   /**
    * 计算金额方法
    * @param b1
    * @param bn
    * @return
    */
   public static BigDecimal safeSubtract(BigDecimal b1, BigDecimal... bn) {
       return safeSubtract(true, b1, bn);
   }
 
   /**
    * BigDecimal的安全减法运算
    * @param isZero  减法结果为负数时是否返回0，true是返回0（金额计算时使用），false是返回负数结果
    * @param b1 被减数
    * @param bn 需要减的减数数组
    * @return
    */
   public static BigDecimal safeSubtract(Boolean isZero, BigDecimal b1, BigDecimal... bn) {
       if (null == b1) {
           b1 = BigDecimal.ZERO;
       }
       BigDecimal r = b1;
       if (null != bn) {
           for (BigDecimal b : bn) {
               r = r.subtract((null == b ? BigDecimal.ZERO : b));
           }
       }
       return isZero ? (r.compareTo(BigDecimal.ZERO) == -1 ? BigDecimal.ZERO : r) : r;
   }
 
   /**
    * 整型的减法运算，小于0时返回0
    * @param b1
    * @param bn
    * @return
    */
   public static Integer safeSubtract(Integer b1, Integer... bn) {
       if (null == b1) {
           b1 = 0;
       }
       Integer r = b1;
       if (null != bn) {
           for (Integer b : bn) {
               r -= Optional.fromNullable(b).or(0);
           }
       }
       return null != r && r > 0 ? r : 0;
   }
 
   /**
    * 金额除法计算
    * @param b1
    * @param b2
    * @return
    */
   public static <T extends Number> BigDecimal safeDivide(T b1, T b2){
       return safeDivide(b1, b2, SCALE, BigDecimal.ZERO);
   }
   
   /**
    * 金额除法计算，返回指定位数的小数
    * @param b1
    * @param b2
    * @param scale 要保留的小数位
    * @return
    */
   public static <T extends Number> BigDecimal safeDivide(T b1, T b2, int scale){
       return safeDivide(b1, b2, scale, BigDecimal.ZERO);
   }
 
   /**
    * BigDecimal的除法运算封装，返回指定位数的小数，如果除数或者被除数为0，返回默认值
    * 默认返回小数位后2位，用于金额计算
    * @param b1
    * @param b2
    * @param scale 要保留的小数位
    * @param defaultValue 返回的默认值
    * @return
    */
   public static <T extends Number> BigDecimal safeDivide(T b1, T b2, int scale, T defaultValue) {
       if (null == b1 || null == b2) {
           return BigDecimal.valueOf(defaultValue.doubleValue());
       }
       try {
           return BigDecimal.valueOf(b1.doubleValue()).divide(BigDecimal.valueOf(b2.doubleValue()), scale, BigDecimal.ROUND_HALF_UP);
       } catch (Exception e) {
           return BigDecimal.valueOf(defaultValue.doubleValue());
       }
   }
 
   /**
    * BigDecimal的乘法运算封装
    * @param b1
    * @param b2
    * @return
    */
   public static <T extends Number> BigDecimal safeMultiply(T b1, T b2) {
       return safeMultiply(b1, b2,SCALE);
   }
   
   /**
    * BigDecimal的乘法运算封装，返回指定位数的小数
    * @param b1 
    * @param b2
    * @param scale 要保留的小数位
    * @return
    */
   public static <T extends Number> BigDecimal safeMultiply(T b1, T b2,int scale) {
       if (null == b1 || null == b2) {
           return BigDecimal.ZERO;
       }
       return BigDecimal.valueOf(b1.doubleValue()).multiply(BigDecimal.valueOf(b2.doubleValue())).setScale(scale, BigDecimal.ROUND_HALF_UP);
   }  
   
   /**
    * 保留N位小数,N位之后的四舍五入<br>
    *
    * @param current  : 当前需要改变的
    * @param position : 位数
    * @return
    */
   public static BigDecimal setScaleDown (BigDecimal current, int position ) {
       return current.setScale( position, BigDecimal.ROUND_HALF_UP );
   }
   
   /**
    * 判断是否是一个正数
    * <p>正数定义：比0大的实数叫正数[,正数前面常有一个符号"+",通常可以省略不写.</p>
    *
    * @param bigDecimal
    * @return
    */
   public static boolean isPositiveNumber ( BigDecimal bigDecimal ) {
       return bigDecimal.compareTo( BigDecimal.ZERO ) == 1;
   }
   
   /**
    * 判断是否不是一个正数
    *
    * @param bigDecimal
    * @return
    */
   public static boolean isNotPositiveNumber ( BigDecimal bigDecimal ) {
       return ! isPositiveNumber( bigDecimal );
   }
   
   /**
    * 判断两个参数是否相等
    *
    * @param before
    * @param after
    * @return
    */
   public static boolean isEqual ( BigDecimal before, BigDecimal after ) {
       return before.compareTo( after ) == 0;
   }
   
   
}

　　实际项目实践可以参考：https://www.cnblogs.com/summary-2017/p/9535671.html

写博客是为了记住自己容易忘记的东西，另外也是对自己工作的总结，文章可以转载，无需版权。希望尽自己的努力，做到更好，大家一起努力进步！

如果有什么问题，欢迎大家一起探讨，代码如有问题，欢迎各位大神指正！