高精度数学运算处理类

于 2022-08-30 10:14:36 发布
阅读量90 收藏
点赞数
文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50756063/article/details/126598259
版权 
package **.tool;

import java.math.BigDecimal;
import java.util.List;

/**
 * 用于高精确处理常用的数学运算
 * @author sean
 * @date 2020/1/2 14:17
 */
public class ArithmeticUtils {
    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    /**
     * 提供精确的加法运算
     *
     * @param arr 数组
     * @return 数组所有数字的和
     */
    public static double add(double... arr) {
        if (arr.length == 0) {
            return 0.0;
        } else if (arr.length == 1) {
            return arr[0];
        } else {
            Double v1 = null;
            for (Double v2 : arr) {
                if (v1 == null) {
                    v1 = v2;
                } else {
                    BigDecimal b1 = BigDecimal.valueOf(v1);
                    BigDecimal b2 = BigDecimal.valueOf(v2);
                    v1 = b1.add(b2).doubleValue();
                }
            }
            return v1;
        }
    }

    public static double add(List<Double> arr) {
        if (arr.size() == 0) {
            return 0.0;
        } else if (arr.size() == 1) {
            return arr.get(0);
        } else {
            Double v1 = null;
            for (Double v2 : arr) {
                if (v1 == null) {
                    v1 = v2;
                } else {
                    BigDecimal b1 = BigDecimal.valueOf(v1);
                    BigDecimal b2 = BigDecimal.valueOf(v2);
                    v1 = b1.add(b2).doubleValue();
                }
            }
            return v1;
        }
    }


    /**
     * 提供精确的加法运算
     *
     * @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 BigDecimal add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2);
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1    被加数
     * @param v2    加数
     * @param scale 保留scale 位小数
     * @return 两个参数的和
     */
    public static String add(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的减法运算
     *
     * @param arr 数组
     * @return 数组所有数字的差
     */
    public static double sub(double... arr) {
        if (arr.length == 0) {
            return 0.0;
        } else if (arr.length == 1) {
            return arr[0];
        } else {
            Double v1 = null;
            for (Double v2 : arr) {
                if (v1 == null) {
                    v1 = v2;
                } else {
                    BigDecimal b1 = BigDecimal.valueOf(v1);
                    BigDecimal b2 = BigDecimal.valueOf(v2);
                    v1 = b1.subtract(b2).doubleValue();
                }
            }
            return v1;
        }
    }

    /**
     * 提供精确的减法运算
     *
     * @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 BigDecimal sub(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2);
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1    被减数
     * @param v2    减数
     * @param scale 保留scale 位小数
     * @return 两个参数的差
     */
    public static String sub(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的乘法运算
     *
     * @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();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static BigDecimal mul(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @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 round(b1.multiply(b2).doubleValue(), scale);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static String mul(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后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();
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示需要精确到小数点以后几位
     * @return 两个参数的商
     */
    public static String div(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v1);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @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));
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static String round(String v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static String remainder(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数  BigDecimal
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 比较大小
     *
     * @param v1 被比较数
     * @param v2 比较数
     * @return 如果v1 大于v2 则 返回true 否则false
     */
    public static boolean compare(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        int bj = b1.compareTo(b2);
        boolean res;
        if (bj > 0) {
            res = true;
        }
        else {
            res = false;
        }
        return res;
    }
}
木易--杨
关注
BigDecimalUtils(BigDecimal工具类)
IRhythm的博客
07-02 1万+
public class BigDecimalUtils { public static final int MONEY_POINT = 2; // 货币保留两位小数 /** * 格式化精度 * * @param v * @param point * 小数位数 * @return double */ ...
Java浮点型数据计算（摘抄）
兽族洞穴
11-26 394
import java.math.BigDecimal; public class Arith { // 默认除法运算精度 private static final int DEF_DIV_SCALE = 10; /** * 提供精确的加法运算 * @param v1 被加数 * @param v2 加数 *...
BigDecimalUtils
01-18
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。
ArithmeticUtils-高精度数学运算工具类
weixin_44801549的博客
06-06 667
package com.org.cn.utils; import java.math.BigDecimal; /** * 用于高精确处理常用的数学运算 */ public class ArithmeticUtils { //默认除法运算精度 private static final int DEF_DIV_SCALE = 10; /** * 提供精确的加法运算 * * @param v1 被加数 * @param v2 加数 * @return 两个参数的和 *.
BigDecimalUtil
qq_20867981的博客
03-21 393
bigdecimal经常用于精确计算，尤其是计算金额的时候。public class BigDecimalUtil { private BigDecimalUtil(){ } public static BigDecimal add(double v1,double v2){ BigDecimal b1 = new BigDecimal(Double...
ArithmeticUtils-高精度数学运算.pdf
06-06
ArithmeticUtils是一个封装了多种高精度数学运算方法的工具类，它利用了BigDecimal的特性，提供了一系列的加、减、乘、除等运算方法。通过封装这些方法，ArithmeticUtils简化了在Java程序中进行高精度运算的过程。 ...
高精度数学运算工具类
"该文档提供了一个名为`ArithmeticUtils`的BigDecimal工具类，用于进行高精度的数学运算，包括加法、减法、乘法和除法操作。这个类内部定义了一个默认的除法运算精度（DEF_DIV_SCALE）为10，并提供了不同参数版本的...
高精确处理常用的数学运算工具类
06-20
高精确处理常用的数学运算工具类，包含多种入参场景的加减乘除运算方法，百分比，等。 可用于精确的数学计算，比如金额等数据运算。也可以基于此工具类按需二次开发，提升效率。
ArithmeticUtils用于高精确处理常用的数学运算工具类
最新发布
08-17
ArithmeticUtils用于高精确处理常用的数学运算工具类 提供精确的加法运算 提供精确的减法运算 提供精确的乘法运算 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到小数点以后10位，以后的数字四舍五入 ...
高精度大数运算类
12-12
该大数运算类是一个支持超高精度和超大数的基本运算类，最高精度能够达到一百亿位有效数字，最大能够表示10的2147483648次方，支持基础的四则运算和比较运算。该类的特点是使用指数形式表示数据，应此空间占用少，运算速度比较快。该类库是基于MFC 的动态连接库，方便VS的开发环境。 该类库包含两个无符号整数类、两个有符号整数类和一个浮点数类，整数又分为带指数的和不带指数的两种，所以总共有不带指数的无符号整数类、带指数的无符号整数类、不带指数的有符号指数类、带指数的有符号指数类和浮点数类，不带指数的类用于循环计数等场合，这些场合通常不是10的整数倍，应此没有必要使用指数形式表示，带指数的类通常用于比较大的但是是10的整数倍，如光的速度等，使用带指数的类来计算即可节约存储空间，也可提高运算速度。
java bigdecimalutils_BigDecimalUtil 工具类
weixin_33305349的博客
02-28 435
一、为什么要用BigDecimal？涉及到加减乘除，用int，double 会出现数据丢失，这个时候就要用BigDecimal。注意:在new BigDecimal(Double.toString(v1)，里面要传入String类型，不然不行。二、用法：public class BigDecimalUtil {// 除法运算默认精度private static final int DEF_DIV_...
【utils】BigDecimalUtil
shiki_41的博客
05-07 438
public class BigDecimalUtil { private static final BigDecimal ZERO = new BigDecimal(0); // 是否大于0 public static boolean isBiggerThanZero(BigDecimal value){ return value.compareTo(...
关于double,float的精度丢失(二)
fengjie_java的专栏
06-06 1195
为什么double转float不会出现数据误差，而float转double却误差如此之大？ class Text {         public static void main(String[] args)         {                 float f = 0.15f;                 double d = f;
Java的数学运算处理类讲解代码（BigDecimal、Math、Random、DecimalFormat类全部操作方法API）
06-27
高精度计算：当需要进行高精度的数学计算时，如金融应用、科学计算等。 舍入规则控制：当需要精确控制数字舍入规则时，如货币计算、统计分析等。 随机数生成：当需要生成伪随机数以支持随机性需求时，如游戏开发、...
高精度运算
weixin_44606952的博客
10-24 112
小学生算数： 计算出进位的个数，输入的数字不超过九位，所以用int来读入即可； 算法思想：将每一个数的个位数相加，然后用一个变量记录进位，在下一次将个位相加的时候加上进位，在每一次将个位数上的数加后，以后个位上的数就没用了，将其剔除掉就行； 代码： #include<stdio.h>//进位计算 int main() { int n,m; while(scanf("%d%d", ...
BigDecimalUtil工具类
Kerwin Ma 的博客
08-22 9004
在java程序中，如果使用double运算，容易丢失精度。 为了防止丢失精度，使用BigDecimal运算，就可以解决java程序运算丢失精度的问题。 下面是为了使用方便，编写的BigDecimal工具类，共享出来，方便大家使用。 package com.utils.util; import java.math.BigDecimal; /** * @author MCJ * @dat...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值