欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java数学工具类MathUtil详解

程序员文章站 2022-06-14 13:43:54
本文实例为大家分享了java数学工具类mathutil的具体代码,供大家参考,具体内容如下 package cn.xbz.util.math; impor...

本文实例为大家分享了java数学工具类mathutil的具体代码,供大家参考,具体内容如下

package cn.xbz.util.math;
 
import java.math.bigdecimal;
 
/**
 * @title 数学计算工具类
 * @description 提供常用的数值加减乘除计算 , 及多个数值的求和 , 平均值 , 最大最小值计算
 */
public class xmathutil {
  /** 默认的除法精确度 */
  private static final int def_div_scale = 2;
 
  /**
   * 精确加法运算
   * @param v1 被加数
   * @param v2 加数
   * @return 两个参数的和(bigdecimal)
   */
  public static bigdecimal add(bigdecimal v1, bigdecimal v2) {
    if (null == v1) {
      v1 = bigdecimal.zero;
    }
    if (null == v2) {
      v2 = bigdecimal.zero;
    }
    return v1.add(v2);
  }
 
  /**
   * 精确减法运算
   * @param v1 被减数
   * @param v2 减数
   * @return 两个参数的差(bigdecimal)
   */
  public static bigdecimal subtract(bigdecimal v1, bigdecimal v2) {
    if (null == v1) {
      v1 = bigdecimal.zero;
    }
    if (null == v2) {
      v2 = bigdecimal.zero;
    }
    return v1.subtract(v2);
  }
 
  /**
   * 精确乘法运算
   * @param v1 被乘数
   * @param v2 乘数
   * @return 两个参数的积(bigdecimal)
   */
  public static bigdecimal multiply(bigdecimal v1, bigdecimal v2) {
    if (null == v1) {
      v1 = bigdecimal.one;
    }
    if (null == v2) {
      v2 = bigdecimal.one;
    }
    return v1.multiply(v2);
  }
 
  /**
   * ( 相对 )精确除法运算 , 当发生除不尽情况时 , 精确到 小数点以后2位 , 以后数字四舍五入
   * @param v1 被除数
   * @param v2 除数
   * @return 两个参数的商(bigdecimal)
   */
  public static bigdecimal divide(bigdecimal v1, bigdecimal v2) {
    return v1.divide(v2, def_div_scale, bigdecimal.round_half_up);
  }
 
  /**
   * ( 相对 )精确除法运算 . 当发生除不尽情况时 , 由scale参数指 定精度 , 以后数字四舍五入
   * @param v1 被除数
   * @param v2 除数
   * @param scale 表示表示需要精确到小数点以后几位
   * @return 两个参数的商(bigdecimal)
   */
  public static bigdecimal divide(bigdecimal v1, bigdecimal v2, integer scale) {
    if (null == v1) {
      return bigdecimal.zero;
    }
    if (null == v2) {
      v2 = bigdecimal.one;
    }
 
    if (v2.compareto(bigdecimal.zero) == 0) {
      throw new illegalargumentexception("除数不能为0");
    }
 
    if (scale < 0) {
      throw new illegalargumentexception("精确度不能小于0");
    }
 
    return v1.divide(v2, scale, bigdecimal.round_half_up);
  }
 
  /**
   * 精确加法运算
   * @param v1 被加数
   * @param v2 加数
   * @return 两个参数的和(string)
   */
  public static string add(string v1, string v2) {
    if (isblank(v1)) {
      v1 = "0";
    }
    if (isblank(v2)) {
      v2 = "0";
    }
    bigdecimal b1 = new bigdecimal(v1.trim());
    bigdecimal b2 = new bigdecimal(v2.trim());
    return string.valueof(add(b1, b2));
  }
 
 
  /**
   * 精确减法运算
   * @param v1 被减数
   * @param v2 减数
   * @return 两个参数的差(string)
   */
  public static string subtract(string v1, string v2) {
    if (isblank(v1)) {
      v1 = "0";
    }
    if (isblank(v2)) {
      v2 = "0";
    }
    bigdecimal b1 = new bigdecimal(v1.trim());
    bigdecimal b2 = new bigdecimal(v2.trim());
    return string.valueof(subtract(b1, b2));
  }
 
  /**
   * 精确乘法运算
   * @param v1 被乘数
   * @param v2 乘数
   * @return 两个参数的积(string)
   */
  public static string multiply(string v1, string v2) {
    if (isblank(v1)) {
      v1 = "1";
    }
    if (isblank(v2)) {
      v2 = "1";
    }
    bigdecimal b1 = new bigdecimal(v1.trim());
    bigdecimal b2 = new bigdecimal(v2.trim());
    return string.valueof(multiply(b1, b2));
  }
 
  /**
   * ( 相对 )精确除法运算 , 当发生除不尽情况时 , 精确到 小数点以后2位 , 以后数字四舍五入
   * @param v1 被除数
   * @param v2 除数
   * @return 两个参数的商(string)
   */
  public static string divide(string v1, string v2) {
    return divide(v1, v2, def_div_scale);
  }
 
  /**
   * ( 相对 )精确除法运算 . 当发生除不尽情况时 , 由scale参数指 定精度 , 以后数字四舍五入
   * @param v1 被除数
   * @param v2 除数
   * @param scale 表示表示需要精确到小数点以后几位
   * @return 两个参数的商(string)
   */
  public static string divide(string v1, string v2, integer scale) {
    if (null == v1) {
      return "0";
    }
    if (null == v2) {
      v2 = "1";
    }
    bigdecimal b1 = new bigdecimal(v1.trim());
    bigdecimal b2 = new bigdecimal(v2.trim());
    return string.valueof(divide(b1, b2, scale));
  }
 
  /**
   * 精确加法运算 , 计算多个数值总和 , 若其中有null值则忽略
   * @param vallist 被加数集合
   * @return 两个参数的和(bigdecimal)
   */
  public static bigdecimal sum(bigdecimal v1, bigdecimal... vallist) {
    if (null == v1) {
      v1 = bigdecimal.zero;
    }
    if (null == vallist || vallist.length == 0) {
      return v1;
    }
    for (bigdecimal val : vallist) {
      if (null != val) {
        v1 = v1.add(val);
      }
    }
    return v1;
  }
 
  /**
   * 精确加法运算 , 计算多个数值总和 , 若其中有null值则忽略
   * @param vallist 被加数集合
   * @return 两个参数的和(string)
   */
  public static string sum(string v1, string... vallist) {
    if (isblank(v1)) {
      v1 = "0";
    }
    if (null == vallist || vallist.length == 0) {
      return v1;
    }
    bigdecimal b1 = new bigdecimal(v1.trim());
    for (string val : vallist) {
      if (!isblank(val)) {
        b1 = add(b1, new bigdecimal(val.trim()));
      }
    }
    return string.valueof(b1);
  }
 
  /**
   * 平均数
   * @param vallist
   * @return
   */
  public static bigdecimal avg(bigdecimal... vallist) {
    if (null != vallist && vallist.length != 0) {
      return divide(sum(bigdecimal.zero, vallist), new bigdecimal(vallist.length));
    }
    return bigdecimal.zero;
  }
 
  /**
   * 平均数
   * @param vallist
   * @return
   */
  public static string avg(string... vallist) {
    if (null != vallist && vallist.length != 0) {
      return divide(sum("0", vallist), string.valueof(vallist.length));
    }
    return "0";
  }
 
  /**
   * 最大值
   * @param v1
   * @param vallist
   * @return
   */
  public static bigdecimal max(bigdecimal v1, bigdecimal... vallist) {
    bigdecimal max = v1;
    if (null == vallist || vallist.length == 0) {
      return max;
    }
    for (bigdecimal val : vallist) {
      if (null != val && val.compareto(max) > 0) {
        max = val;
      }
    }
    return max;
  }
 
  /**
   * 最大值
   * @param vallist
   * @return
   */
  public static bigdecimal maxarr(bigdecimal... vallist) {
    if (null == vallist || vallist.length == 0) {
      return null;
    }
 
    return max(vallist[0], vallist);
  }
 
  /**
   * 最小值
   * @param v1
   * @param vallist
   * @return
   */
  public static bigdecimal min(bigdecimal v1, bigdecimal... vallist) {
    bigdecimal min = v1;
    if (null == vallist || vallist.length == 0) {
      return min;
    }
    for (bigdecimal val : vallist) {
      if (null != val && val.compareto(min) < 0) {
        min = val;
      }
    }
    return min;
  }
 
  /**
   * 最小值
   * @param vallist
   * @return
   */
  public static bigdecimal minarr(bigdecimal... vallist) {
    if (null == vallist || vallist.length == 0) {
      return null;
    }
    return min(vallist[0], vallist);
  }
 
  /**
   * 最大值
   * @param v1
   * @param vallist
   * @return
   */
  public static string max(string v1, string... vallist) {
    if (isblank(v1)) {
      return null;
    }
    if (null == vallist || vallist.length == 0) {
      return v1;
    }
    bigdecimal maxbd = new bigdecimal(v1.trim());
 
    for (string val : vallist) {
      if (!isblank(val) && new bigdecimal(val).compareto(maxbd) > 0) {
        maxbd = new bigdecimal(val);
      }
    }
    return string.valueof(maxbd);
  }
 
  /**
   * 最大值
   * @param vallist
   * @return
   */
  public static string maxarr(string... vallist) {
    if (null == vallist || vallist.length == 0) {
      return null;
    }
    return max(vallist[0], vallist);
  }
 
  /**
   * 最小值
   * @param v1
   * @param vallist
   * @return
   */
  public static string min(string v1, string... vallist) {
    if (isblank(v1)) {
      return null;
    }
    if (null == vallist || vallist.length == 0) {
      return v1;
    }
    bigdecimal minbd = new bigdecimal(v1.trim());
 
    for (string val : vallist) {
      if (!isblank(val) && new bigdecimal(val).compareto(minbd) < 0) {
        minbd = new bigdecimal(val);
      }
    }
    return string.valueof(minbd);
  }
 
  /**
   * 最小值
   * @param vallist
   * @return
   */
  public static string minarr(string... vallist) {
    if (null == vallist || vallist.length == 0) {
      return null;
    }
    return min(vallist[0], vallist);
  }
 
  /**
   * 判断字符串是否为空(不依赖第三方)
   * @param str
   * @return
   */
  private static boolean isblank(string str) {
    return null == str || str.trim().length() == 0;
  }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。