zoukankan      html  css  js  c++  java
  • java精确计算工具类

    java精确计算工具类

    import java.math.BigDecimal;
    import java.math.RoundingMode;
    import java.math.BigDecimal;
    import java.text.DecimalFormat;
    
    import org.springframework.stereotype.Component;
    
    /**
     * 工具类 - 运算
     */
    
    @Component
    public class ArithUtils {
    
        // 默认除法运算精度
        private static final int DEF_DIV_SCALE = 10;
    
        private ArithUtils() {
    
        }
    
        /**
         * 提供精确的加法运算。如果参数为null,则视为0处理。
         * 
         * @param v1
         *            被加数
         * @param v2
         *            加数
         * @return 两个参数的和
         */
        public static double add(Double v1, Double v2) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1==null?0D:v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2==null?0D:v2));
            return b1.add(b2).doubleValue();
        }
    
        /**
         * 提供精确的加法运算。
         * 
         * @param vs
         *            加数
         * @return*/
        public static double add(Double... vs) {
            BigDecimal b1 = new BigDecimal(0);
            for (Double d : vs) {
                BigDecimal b2 = new BigDecimal(Double.toString(d==null?0D:d));
                b1 = b1.add(b2);
            }
            return b1.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();
        }
        
        /**
         * 提供精确的乘法运算。
         * 
         * @return 多个values的乘积
         */
        public static double mul(Double... values) {
            BigDecimal result = new BigDecimal(1);
            for(Double value : values){
                result = result.multiply( new BigDecimal(Double.toString(value)) );
            }
            return result.doubleValue();
        }
        
        /**
         * 提供精确的乘法运算。
         * 
         * @param v1
         *            被乘数
         * @param v2
         *            乘数
         * @return 两个参数的积
         */
        public static double mul(double v1, double v2, int scale) {
            BigDecimal b1 = new BigDecimal(Double.toString(v1));
            BigDecimal b2 = new BigDecimal(Double.toString(v2));
            return ArithUtils.round(b1.multiply(b2).doubleValue(), scale);
        }
    
        /**
         * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 小数点以后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("参数scale必须为整数为零!");
            }
            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("参数scale必须为整数或零!");
            }
            BigDecimal b = new BigDecimal(Double.toString(v));
            BigDecimal one = new BigDecimal("1");
            return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    
        /**
         * 提供精确的类型转换(Float)
         * 
         * @param v
         *            需要被转换的数字
         * @return 返回转换结果
         */
        public static float convertsToFloat(double v) {
            BigDecimal b = new BigDecimal(v);
            return b.floatValue();
        }
    
        /**
         * 提供精确的类型转换(Int)不进行四舍五入
         * 
         * @param v
         *            需要被转换的数字
         * @return 返回转换结果
         */
        public static int convertsToInt(double v) {
            BigDecimal b = new BigDecimal(v);
            return b.intValue();
        }
    
        /**
         * 提供精确的类型转换(Long)
         * 
         * @param v
         *            需要被转换的数字
         * @return 返回转换结果
         */
        public static long convertsToLong(double v) {
            BigDecimal b = new BigDecimal(v);
            return b.longValue();
        }
    
        /**
         * 返回两个数中大的一个值
         * 
         * @param v1
         *            需要被对比的第一个数
         * @param v2
         *            需要被对比的第二个数
         * @return 返回两个数中大的一个值
         */
        public static double returnMax(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.max(b2).doubleValue();
        }
    
        /**
         * 返回两个数中小的一个值
         * 
         * @param v1
         *            需要被对比的第一个数
         * @param v2
         *            需要被对比的第二个数
         * @return 返回两个数中小的一个值
         */
        public static double returnMin(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.min(b2).doubleValue();
        }
    
        /**
         * 精确比较两个数字
         * 
         * @param v1
         *            需要被对比的第一个数
         * @param v2
         *            需要被对比的第二个数
         * @return 如果两个数一样则返回0,如果第一个数比第二个数大则返回1,反之返回-1
         */
        public static int compareTo(double v1, double v2) {
            BigDecimal b1 = new BigDecimal(v1);
            BigDecimal b2 = new BigDecimal(v2);
            return b1.compareTo(b2);
        }
    
        /**
         * 获取数字小数位数
         * 
         * @param number
         *            数字.
         * 
         * @return 小数位数
         */
        public static int getDecimals(double number) {
            DecimalFormat decimalFormat = new DecimalFormat("#.####");
            String numberString = decimalFormat.format(number);
            if (numberString.indexOf(".") > 0) {
                return numberString.length() - String.valueOf(number).indexOf(".")
                        - 1;
            } else {
                return 0;
            }
        }
    
        /**
         * 获取数字小数位数
         * 
         * @param number
         *            数字.
         * 
         * @return 小数位数
         */
        public static int getDecimals(float number) {
            DecimalFormat decimalFormat = new DecimalFormat("#.####");
            String numberString = decimalFormat.format(number);
            if (numberString.indexOf(".") > 0) {
                return numberString.length() - String.valueOf(number).indexOf(".")
                        - 1;
            } else {
                return 0;
            }
        }
    
        /**
         * 对double数据进行取精度.
         * 
         * @param value
         *            double数据.
         * @param scale
         *            精度位数(保留的小数位数).
         * @param roundingMode  : BigDecimal.ROUND_FLOOR(舍去scale位数后所有)
         *            精度取值方式.
         * @return 精度计算后的数据.
         */
        public static double round(double value, int scale, int roundingMode) {
            BigDecimal bd = new BigDecimal(value);
            bd = bd.setScale(scale, roundingMode);
            double d = bd.doubleValue();
            bd = null;
            return d;
        }
    }
  • 相关阅读:
    SQL练习题9:获取所有部门当前(dept_manager.to_date='9999-01-01')manager的当前(salaries.to_date='9999-01-01')薪水情况,给出dept_no, emp_no以及salary(请注意,同一个人可能有多条薪水情况记录)
    SQL练习题8:找出所有员工当前(to_date='9999-01-01')具体的薪水salary情况,对于相同的薪水只显示一次,并按照逆序显示
    数据仓库、数据集市、数据湖、数据中台概念理解
    SQL练习题七:查找薪水变动超过15次的员工号emp_no以及其对应的变动次数t
    SQL练习题6:查找所有员工入职时候的薪水情况,给出emp_no以及salary, 并按照emp_no进行逆序(请注意,一个员工可能有多次涨薪的情况)
    SQL练习五:查找所有员工的last_name和first_name以及对应部门编号dept_no,也包括暂时没有分配具体部门的员工(请注意输出描述里各个列的前后顺序)
    SQL练习题四:查找所有已经分配部门的员工的last_name和first_name以及dept_no(请注意输出描述里各个列的前后顺序)
    SQL练习题三: 查找各个部门当前(dept_manager.to_date='9999-01-01')领导当前(salaries.to_date='9999-01-01')薪水详情以及其对应部门编号dept_no (注:请以salaries表为主表进行查询,输出结果以salaries.emp_no升序排序,并且请注意输出结果里面dept_no列是最后一列)
    SQL练习题二:查找入职员工时间排名倒数第三的员工所有信息,为了减轻入门难度,目前所有的数据里员工入职的日期都不是同一天
    [CF1379E]Inverse Genealogy
  • 原文地址:https://www.cnblogs.com/weitaming/p/11490668.html
Copyright © 2011-2022 走看看