数据计算时使用的工具类

最新推荐文章于 2022-04-27 10:46:49 发布
最新推荐文章于 2022-04-27 10:46:49 发布
阅读量177 收藏
点赞数
分类专栏： java架构师之路 jdk1.8 源码 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qcsdn123/article/details/120885474
版权

关注我，升职加薪就是你！
金融项目做多了，不可能每次遇到需要计算的，都要重新写工具类。由于这部分代码是公共的，就把它记录在这里吧，省的下次再写这些重复性的东西。如果对你们有帮助，你们也可以收藏保存下来。
话不多说，下面就直接上代码吧。

package com.demo.nacosprovider.common;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.math.BigDecimal;
import java.text.DecimalFormat;

/**
 * @Author: Paul
 * @Date: 2021/10/28
 * @Function: 数值计算工具类
 */
public class BigDecimalUtils {

    private static Logger logger = LoggerFactory.getLogger(BigDecimalUtils.class);

    /**
     * 小数位默认取2位
     */
    private static final Integer DEFAULT_SCALE = 2;

    public static final BigDecimal BigDecimal_100 = new BigDecimal("100");

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 获取数值对象
     * @param: [value]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal getBigDecimal(Object value) {
        BigDecimal result = null;
        try {
            result = new BigDecimal(value.toString());
        } catch (Exception e) {
            logger.error("非法参数，无法转为Bigdecimal类型");
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 获取数值对象
     * @param: [value, defaultValue]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal getBigDecimal(Object value, Number defaultValue) {
        BigDecimal result = null;
        try {
            result = new BigDecimal(value.toString());
        } catch (Exception e) {
            logger.error("非法参数，无法转为Bigdecimal类型");
            result = new BigDecimal(defaultValue.toString());
        }
        return result;
    }


    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的加法运算，获取所有参数的和
     * @param: [values]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal add(Number... values) {
        BigDecimal result = BigDecimal.ZERO;
        if (values == null || values.length == 0) {
            return result;
        }
        for (Number value : values) {
            if (value != null) result = result.add(new BigDecimal(value.toString()));
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的加法运算，获取所有参数的和
     * @param: [values]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal add(BigDecimal... values) {
        BigDecimal result = BigDecimal.ZERO;

        if (values == null || values.length == 0) {
            return result;
        }
        for (BigDecimal value : values) {
            if (value != null) result = result.add(value);
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的减法运算。
     * @param: [value1, value2]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal sub(Number value1, Number... value2) {
        BigDecimal result = BigDecimal.ZERO;
        if(value1 != null) {
            result = result.add(new BigDecimal(value1.toString()));
        }
        if(value2 == null || value2.length == 0) {
            return result;
        };
        for(Number value : value2) {
            if(value != null) result = result.subtract(new BigDecimal(value.toString()));
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的减法运算。value1 - value2
     * @param: [value1, value2]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal sub(BigDecimal value1, BigDecimal... value2) {
        BigDecimal result = BigDecimal.ZERO;
        if (value1 != null) {
            result = result.add(value1);
        }
        if (value2 == null || value2.length == 0) {
            return result;
        }
        for (BigDecimal value : value2) {
            if (value != null) result = result.subtract(value);
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的乘法运算
     * @param: [values]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal mul(Number... values) {
        if (values == null || values.length == 0) {
            return null;
        }
        BigDecimal result = BigDecimal.ONE;
        for (Number value : values) {
            if (value != null) result = result.multiply(new BigDecimal(value.toString()));
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的乘法运算
     * @param: [values]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal mul(BigDecimal... values) {
        if (values == null || values.length == 0) {
            return null;
        }
        BigDecimal result = BigDecimal.ONE;
        for (BigDecimal value : values) {
            if (value != null) result = result.multiply(value);
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供（相对）精确的除法运算
     * @param: [dividend, divisor]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal div(Number dividend, Number divisor) {
        return div(dividend, divisor, DEFAULT_SCALE);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供（相对）精确的除法运算
     * @param: [dividend, divisor]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal div(BigDecimal dividend, BigDecimal divisor) {
        return div(dividend, divisor, DEFAULT_SCALE);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供（相对）精确的除法运算
     * @param: [dividend, divisor, scale]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal div(Number dividend, Number divisor, Integer scale) {
        if (dividend == null) return null;
        if (divisor == null || divisor.doubleValue() == 0) {
            throw new IllegalArgumentException(
                    "The divisor cannot be zero or null !");
        }
        if (scale == null) scale = DEFAULT_SCALE;
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(dividend.toString());
        BigDecimal b2 = new BigDecimal(divisor.toString());
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供（相对）精确的除法运算
     * @param: [dividend, divisor, scale]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal div(BigDecimal dividend, BigDecimal divisor, Integer scale) {
        if (dividend == null) return null;
        if (divisor == null || divisor.doubleValue() == 0) {
            throw new IllegalArgumentException(
                    "The divisor cannot be zero or null !");
        }
        if (scale == null) scale = DEFAULT_SCALE;
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return dividend.divide(divisor, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的小数位四舍五入处理
     * @param: [value]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal round(Number value) {
        return round(value, DEFAULT_SCALE);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的小数位四舍五入处理
     * @param: [value]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal round(BigDecimal value) {
        return round(value, DEFAULT_SCALE);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的小数位四舍五入处理
     * @param: [value, scale]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal round(BigDecimal value, Integer scale) {
        if (value == null) return null;
        if (scale == null) scale = DEFAULT_SCALE;
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return value.setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 提供精确的小数位四舍五入处理
     * @param: [value, scale]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal round(Number value, Integer scale) {
        if (value == null) return null;
        if (scale == null) scale = DEFAULT_SCALE;
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(value.toString());
        return b.divide(BigDecimal.ONE, scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 格式化输出 (默认保留2位小数)
     * @param: [value]
     * @return: java.lang.String
     */
    public static String format(BigDecimal value) {
        if (value == null) {
            throw new IllegalArgumentException("The value must be a valid value.");
        }
        DecimalFormat df = new DecimalFormat(".00");
        return df.format(value);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 比较返回小的
     * @param: [a, b]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal min(Object a, Object b) {
        BigDecimal i = new BigDecimal(String.valueOf(a));
        BigDecimal j = new BigDecimal(String.valueOf(b));
        return i.compareTo(j) < 0 ? i : j;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 比较返回小的
     * @param: [a, b]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal min(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) < 0 ? a : b;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 比较返回大的
     * @param: [a, b]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal max(BigDecimal a, BigDecimal b) {
        return a.compareTo(b) > 0 ? a : b;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 返回百分比
     * @param: [a]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal toPercent(BigDecimal a) {
        return a.divide(new BigDecimal("100"));
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 对象为null时转换为零
     * @param: [a]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal transNullToZERO(BigDecimal a) {
        return a == null ? BigDecimal.ZERO : a;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 将null或空字符转换为零
     * @param: [a]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal transNullStringToZERO(String a) {
        if (StringUtils.isEmptyStr(a)) {
            return BigDecimal.ZERO;
        }
        return new BigDecimal(a.trim());
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 功能描述：负数转0
     * @param: [a]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal transMinusToZERO(BigDecimal a) {
        return a.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : a;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 由于java语言中对浮点数的二进制转换会产生问题，因此在将浮点数转换为BigDecimal类型时需要先将浮点数转换为String型
     * @param: [num]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal getExactBigDicimal(double num) {
        String numStr = num + "";
        return new BigDecimal(numStr);
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 校验是否为小于等于零的数字
     * @param: [number]
     * @return: boolean
     */
    public static boolean isNotPlus(BigDecimal number) {
        if (number == null) {
            return true;
        }
        if (number.compareTo(new BigDecimal(0)) <= 0) {
            return true;
        }
        return false;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 校验是否大于零的数字
     * @param: [number]
     * @return: boolean
     */
    public static boolean isGreaterZero(BigDecimal number) {
        if (number == null) {
            return false;
        }
        if (number.compareTo(new BigDecimal(0)) <= 0) {
            return false;
        }
        return true;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 将可能为空的BigDecimal转为BigDecimal
     * @param: [num]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal convertBigDecimal(BigDecimal num) {
        if (num == null) {
            num = new BigDecimal(0);
        }
        return num;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 将可能为空的Integer转为0
     * @param: [integer]
     * @return: java.lang.Integer
     */
    public static Integer convertInteger(Integer integer) {
        if (integer == null) {
            integer = new Integer(0);
        }
        return integer;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 将BigDecimal转为BigDecimal, 允许自己定义异常时的返回值
     * @param: [num, bd]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal convertBigDecimal(BigDecimal num, BigDecimal bd) {
        if (num == null) {
            return bd;
        }
        return num;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 将BigDecimal转为String
     * @param: [num]
     * @return: java.lang.String
     */
    public static String covertBigDecimalToString(BigDecimal num) {
        if (num == null) {
            return "";
        }
        return num.toString();
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 将BigDecimal转为double
     * @param: [num]
     * @return: double
     */
    public static double toDouble(BigDecimal num) {
        if (num == null) {
            return 0;
        }
        return num.doubleValue();
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 判断bd1是否小于bd2
     * @param: [bd1, bd2]
     * @return: boolean
     */
    public static boolean compareBigDecimalMinus(BigDecimal bd1, BigDecimal bd2) {
        boolean returnFlag = false;
        int i1 = bd1.compareTo(bd2);
        if (i1 < 0) {
            returnFlag = true;
        }
        return returnFlag;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 判断bd1是否小于等于bd2
     * @param: [bd1, bd2]
     * @return: boolean
     */
    public static boolean compareBigDecimalMinusEq(BigDecimal bd1, BigDecimal bd2) {
        boolean returnFlag = false;
        int i1 = bd1.compareTo(bd2);
        if (i1 < 0 || i1 == 0) {
            returnFlag = true;
        }
        return returnFlag;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 判断bd1是否大于bd2
     * @param: [bd1, bd2]
     * @return: boolean
     */
    public static boolean compareBigDecimalPlus(BigDecimal bd1, BigDecimal bd2) {
        boolean returnFlag = false;
        int i1 = bd1.compareTo(bd2);
        if (i1 > 0) {
            returnFlag = true;
        }
        return returnFlag;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 判断BigDecimal是否为null
     * @param: [bigDecimal]
     * @return: boolean
     */
    public static boolean isNullBigDecimal(BigDecimal bigDecimal) {
        boolean result = false;
        if (bigDecimal == null) {
            result = true;
        }
        return result;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 判断BigDecimal是否大于或等于零，为null时返回false
     * @param: [bigDecimal]
     * @return: boolean
     */
    public static boolean isGreaterOrEqualToZero(BigDecimal bigDecimal) {
        boolean result = false;
        if (BigDecimalUtils.isNullBigDecimal(bigDecimal)) {
            return result;
        }
        if (bigDecimal.compareTo(BigDecimal.ZERO) >= 0) {
            result = true;
        }
        return result;

    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 如果bigDecimal等于0则返回1，否则返回bigDecimal
     * @param: [bigDecimal]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal transZEROToONE(BigDecimal bigDecimal) {
        if (BigDecimal.ZERO.compareTo(bigDecimal) == 0) {
            return BigDecimal.ONE;
        } else {
            return bigDecimal;
        }
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 判断两个BigDecimal 是否相等
     * @param: [one, two]
     * @return: boolean
     */
    public static boolean isEqual(BigDecimal one, BigDecimal two) {
        return one.compareTo(two) == 0 ? true : false;
    }

    /**
     * @author: Paul
     * @time: 2021/10/28
     * @description: 对BigDecimal类型进行四舍五入并返回BigDecimal
     * @param: [one, size]
     * @return: java.math.BigDecimal
     */
    public static BigDecimal roundBigDecimal(BigDecimal one, int size) {
        return one.setScale(size, BigDecimal.ROUND_HALF_UP);
    }

}

上述需要用到字符串工具类的一些方法，我就自己搞了个字符串工具类StringUtils 。

/**
 * @Author: Paul
 * @Date: 2021/10/28
 * @Function: 字符串工具类
 */
public class StringUtils {

    /**
     *@author: Paul
     *@time: 2021/10/28
     *@description: 判断字符串是否为空或者为空白串
     *@param: [str]
     *@return: boolean
     */
    public static boolean isEmptyStr(String str) {
        if (null == str || "".equals(str.trim())) {
            return true;
        } else
            return false;
    }

    /**
     *@author: Paul
     *@time: 2021/10/28
     *@description: 判断字符串是否非空
     *@param: [str]
     *@return: boolean
     */
    public static boolean isNotEmpty(String str) {
        return !isEmptyStr(str);
    }
}

好了，今天的分享就到这吧。
See u !
关注我，升职加薪就是你！

徐先生Paul
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java计算工具类
07-22
Java计算工具类,类型转换，用于加减乘除。
运算工具类实现精确计算
09-18
java运算工具类，可以处理浮点数的精度丢失问题，可以实现精确计算，常用公共方法抽取，常用工具类11111111111111111111111111111111111111111111111111111111111111111111111111
【java 计算工具类】
kindboy_bobo的博客
04-27 1049
java 计算工具类 package com.nearfartec.travel.order.utils; import java.math.BigDecimal; import java.text.DecimalFormat; import java.util.Objects; /** * <p>ClassName:CalculateUtil</p> * <p>Description: 计算工具类 </p> * * @author XiangB
精确计算工具类
12-05
Android 精确计算工具类。 /** * @Title: Arith.java * @Package com.uxun.pay.util * @Description: TODO(用一句话描述该文件做什么) * @author daiw * @date 2016-1-5 上午9:05:34 * @version V1.0 */ package com.xwtec.commonutil; import java.math.BigDecimal; /** * Arith * (由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精确的浮点数运算，包括加减乘除和四舍五入) * @author chenke * @time 2017/12/5 16:22 * @mail ch_chenke@163.com */ public class Arith { //默认除法运算精度 private static final int DEF_DIV_SCALE = 10; //这个类不能实例化 private Arith() { } /** * 提供精确的String转换成double * @param v * @return */ public static double strPreDou(String v) { BigDecimal b = new BigDecimal(v); return b.doubleValue(); } /** * 提供精确的加法运算。 * @param v1 被加数 * @param v2 加数 * @return 两个参数的和 */ public static double add(double v1, double v2) { BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b2 = new BigDecimal(Double.toString(v2)); return b1.add(b2).doubleValue(); } /** * 提供精确的减法运算。 * @param v1 被减数 * @param v2 减数 * @return 两个参数的差 */ public static double sub(double v1, double v2) { BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b2 = new BigDecimal(Double.toString(v2)); return b1.subtract(b2).doubleValue(); } /** * 提供精确的乘法运算。 * @param v1 被乘数 * @param v2 乘数 * @return 两个参数的积 */ public static double mul(double v1, double v2) { BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b2 = new BigDecimal(Double.toString(v2)); return b1.multiply(b2).doubleValue(); } /** * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 * 小数点以后10位，以后的数字四舍五入。 * @param v1 被除数 * @param v2 除数 * @return 两个参数的商 */ public static double div(double v1, double v2) { return div(v1, v2, DEF_DIV_SCALE); } /** * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 * 定精度，以后的数字四舍五入。 * @param v1 被除数 * @param v2 除数 * @param scale 表示表示需要精确到小数点以后几位。 * @return 两个参数的商 */ public static double div(double v1, double v2, int scale) { if (scale < 0) { throw new IllegalArgumentException( "The scale must be a positive integer or zero"); } BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b2 = new BigDecimal(Double.toString(v2)); return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue(); } /** * 提供精确的小数位四舍五入处理。 * @param v 需要四舍五入的数字 * @param scale 小数点后保留几位 * @return 四舍五入后的结果 */ public static double round(double v, int scale) { if (scale < 0) { throw new IllegalArgumentException( "The scale must be a positive integer or zero"); } BigDecimal b = new BigDecimal(Double.toString(v)); BigDecimal BigDecimal("1"); return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue(); } }
数字计算工具类
caoniuniu25的专栏
04-22 196
在项目开发过程中，使用到了数值计算,加、减、乘、除。在计算过程中发现，由于计算机的缘故，在数学上能算正确的，在计算机这里可能就会出现无线循环的小数。 遇到这种情况，可以选择使用如下的计算工具。 package cn.com.taiji.util; import java.math.BigDecimal; /** * @author caohl * @date 2019年1月2...
AmountUtil.zip_AmountUtil_数学计算工具类
09-21
《AmountUtil：高效实用的数学计算工具类》 在编程领域，处理数学计算是一项常见的任务，无论是简单的加减乘除，还是复杂的数值比较和四舍五入操作，都需要精确且高效的实现。`AmountUtil`是一个专门用于数学计算的...
MathTool_计算平均值的标准方差_工具类_
10-03
在实际应用中，你可以这样使用这个工具类： ```csharp double[] data = { 1, 2, 3, 4, 5 }; double mean = MathTool.CalculateMean(data); double stdDev = MathTool.CalculateStandardDeviation(data); Console....
JAVA对象以及数据的工具类
03-22
在Java编程语言中，工具类（Utils）是包含各种实用方法的类，这些方法...理解并熟练使用这些工具类，对于提升Java编程能力至关重要。通过不断学习和实践，我们可以更好地利用这些工具类，写出更加高效、健壮的代码。
计算器类3_数据计算_源码
10-04
这个“计算器类3_数据计算_源码”很可能是一个高级的计算工具，它超越了传统的加减乘除，提供了更多的功能，以满足用户对数据处理的需求。下面我们将深入探讨计算器类的设计、数据计算的概念以及可能包含的功能。 ...
常用的数学计算工具类
BlueKitty的博客
11-16 715
package com.xutil.math; import java.math.BigDecimal; /** * @title 数学计算工具类 * @author Xingbz * @createDate 2018年11月16日 */ public class XMathUtil { /** 默认的数据精度 */ private static final int...
matlab常用数值计算工具类代码
05-15
matlab常用数值计算工具类代码，如 解线性方程，微分方程，求根等
Java数值计算工具类NumberUtil(防止java计算产生浮点问题)
老T的专栏
09-21 6721
import java.math.BigDecimal; import java.text.DecimalFormat; import java.util.regex.Matcher; import java.util.regex.Pattern; public class NumberUtil { public static void main(String[] args) { Syst
Java工具类——数字计算工具 NumberUtil
王新友的博客
06-15 1408
[java] view plaincopy package com.luang.util.common;        import java.util.HashSet;     import java.util.Random;     import java.util.Set;           /**   *    * NumberUtil.j
【转】Java工具类——数字计算工具 NumberUtil
小李专栏
04-14 3402
package com.luang.util.common; import java.util.HashSet; import java.util.Random; import java.util.Set; /** * * NumberUtil.java * * @desc 数字计算工具 * @author Guoxp * @datatime Apr 7, 2
java 计算工具类_java精确计算工具类
weixin_35586996的博客
02-16 520
importjava.math.BigDecimal;importjava.math.RoundingMode;importjava.math.BigDecimal;importjava.text.DecimalFormat;importorg.springframework.stereotype.Component;/*** 工具类 - 运算*/@Componentpublic classAri...
（原创）分享自己写的几个工具类（四）BigDecimal精确计算
Android_xiong_st的博客
04-18 2967
java的float只能用来进行科学计算或工程计算，但是 在大多数的商业计算中，一般采用java.math.BigDecimal类来进行精确计算。 比如我们平常常见的支付宝和滴滴打车，如果要模拟运算的话 就必须用到这个类 BigDecimal的使用步骤如下： 1初始化一个BigDecimal对象 这两种方法都可以 BigDecimal bd1 = new BigDecimal
数学计算工具类
weixin_44585705的博客
03-24 636
小数转换成百分比时，保留两位小数 import java.math.BigDecimal; import java.math.BigInteger; import java.text.DecimalFormat; import java.text.NumberFormat; /** * @author Duncino * @date 2022/3/23 */ public class NumberUtils { /** * 计算百分比，保留两位小数 eg 1/4 = 0.25 retu
JAVA精度计算工具类
落叶飘零z的博客
12-25 766
import java.math.BigDecimal; /** * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精确的浮点数运算，包括加減乘除和四捨五入。 */ public class ArithUtils { //默认吃吃饭运算精度 private static final int DEF_DIV_SCALE = 10; //这个...
金额计算工具类
S___Lei的博客
07-22 560
开发中常用工具类，总结记录一番！ 提要： 1、toEngineeringString：有必要时使用工程计数法。工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数 2、toPlainString：不使用任何指数 3、toString：有必要时使用科学计数法 import java.math...
2021年计算机类题库数据结构题库.doc
最新发布
12-18
数据结构是计算机科学中非常重要的一门学科，它为程序员们提供了处理和管理数据的基础知识和工具，因此掌握数据结构是每一个计算机专业学生和从业者所必须具备的技能。 在这份题库中，我们可以看到很多常见的数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

徐先生Paul

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值