精确的数据类型BigDecimal和工具类

最新推荐文章于 2024-05-22 17:43:01 发布
最新推荐文章于 2024-05-22 17:43:01 发布
阅读量806 收藏 2
点赞数
分类专栏： java基础 文章标签： java 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46724069/article/details/128207038
版权

精确的数据类型BigDecimal

初始 BigDecimal

BigDecimal 类在 java.math 包下，继承了 Number 类，实现了比较器的接口，用来对超过 16 位有效位的数进行精确的运算，因为在现实生活中，财务、超市、银行使用基本的数据类型浮点数的时候只满足 16 位有效位，一旦超过 16 位就会出现精度上的丢失。

package java.math;

public class BigDecimal extends Number implements Comparable<BigDecimal>

构造方法

BigDecimal 定义了很多的有参构造函数，十分的丰富，省略了无参构造

BigDecimal(BigInteger intVal, long val, int scale, int prec)

public BigDecimal(char[] in, int offset, int len)

public BigDecimal(char[] in, int offset, int len, MathContext mc)

public BigDecimal(char[] in)

public BigDecimal(char[] in, MathContext mc)

public BigDecimal(String val)

public BigDecimal(String val, MathContext mc)

public BigDecimal(double val)

public BigDecimal(double val, MathContext mc)

public BigDecimal(BigInteger val)

public BigDecimal(BigInteger unscaledVal, int scale)

public BigDecimal(BigInteger unscaledVal, int scale, MathContext mc)

public BigDecimal(int val)

public BigDecimal(int val, MathContext mc)

public BigDecimal(long val)

public BigDecimal(long val, MathContext mc)

测试

    public static void main(String[] args){
        BigDecimal a = new BigDecimal(0.1);
        System.out.println("a ==>"+a);
        BigDecimal b =new BigDecimal("0.1");
        System.out.println("b ==>"+b);

    }

向 BigDecimal 的构造器中传入浮点数 0.1 时候，输出结果不可预知，因为 0.1 无法准确的表示有限长度的 double 的二进制小数。但是 String 的构造器是可预知的，是准确的

a ==>0.1000000000000000055511151231257827021181583404541015625
b ==>0.1

常用属性和方法

静态常量 0 、1 、10 

    public static final BigDecimal ZERO;
    public static final BigDecimal ONE;
    public static final BigDecimal TEN;

常用方法

public BigDecimal add()  // 求和 返回 BigDecimal 

public BigDecimal subtract() // -

public BigDecimal multiply() // * 

public BigDecimal divide() // / 除

public BigDecimal sqrt() // 开平方

public BigDecimal pow() // 幂运算

public BigDecimal abs() // 绝对值运算

public BigDecimal round() // 四舍五入运算

public BigDecimal negate() // 空参取反，有参MathContext(n)，四舍五入保留精度 n

public BigDecimal plus() // 与一元减法方法 negate() 对称，包含此方法，它仅返回此 BigDecimal

public int precision() // 指定精度

// 返回此BigDecimal的精度。如果为零或正数，精度数字在小数点右侧的数字。
// 如果为负数，数的非标度值乘以10比例的负数的幂值。
public int scale() 

public BigDecimal movePointLeft(int n) // 向左移动小数点n位

public int compareTo(BigDecimal val) // 重写比较器

public boolean equals(Object x) // 相等 equals

public BigDecimal min(BigDecimal val) // 最小值

public BigDecimal max(BigDecimal val) // 最大值

public int hashCode() // hash 码

public String toString() // 转为字符串

编写好的工具类

import java.math.BigDecimal;

/**
 * 用于高精确处理常用的数学运算
 */
public class ArithmeticUtils {
    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

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

更多的学习

JDK11

https://www.runoob.com/manual/jdk11api/java.base/java/math/BigDecimal.html

易白教程

https://www.yiibai.com/java/math/java_math_bigdecimal.html

coffee_mao
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BigDecimal 加减乘除工具包
06-03
BigDecimal加减乘除工具包，提供了BigDecial操作以及保留小数位数
java算小数,java 小数运算 - osc_popfjd1t的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_33245735的博客
03-22 213
packagecom.chobits81.cc.utils;importjava.math.BigDecimal;public classMathUtil {public static voidmain(String[] args) {/*String a="1234567891234567891234788778875555555.5678912345678912123456789";Strin...
BigDecimal工具类
最新发布
兴趣是最好的老师
05-22 178
下面我将为你提供一个简单的BigDecimalUtils工具类示例，该类包含了一些常见的数。为null的BigDecimal对象，以避免空指针异常，以及一个格式化输出的方法，用于控制输出结果的。在Java中，BigDecimal是一个用于进行高精度计算的类，特别适合处理货币计算等对精度有严格。这个工具类提供了一些基本的数学运算方法，并且在进行除法运算时，默认保留了两位小数并采用。你可以根据实际需求调整这些默认设置。此外，还提供了一个方法来处理可能。学运算方法，如加、减、乘、除以及比较等。
Java之BigDecimal详解
weixin_43102784的博客
06-07 1474
在需要精确的小数计算时再使用BigDecimal，BigDecimal的性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。尽量使用参数类型为String的构造函数。BigDecimal都是不可变的（immutable）的， 在进行每一次四则运算时，都会产生一个新的对象 ，所以在做加减乘除运算时要记得要保存操作后的值。
BigDecimal 工具类
yangziqi098的博客
06-09 286
BigDecimal 工具类
Java——BigDecimal的工具类
m0_58596092的博客
10-25 1016
BigDecimal的工具类
BigDecimal工具类.docx
05-31
在BigDecimal工具类中，我们可以看到多个重载的方法，例如add方法和sub方法，这些方法可以根据不同的参数类型和精度需求进行选择。 首先，让我们来看一下add方法。add方法有三种重载形式，分别是add(double,double)...
Java中BigDecimal类的简单用法
09-04
Decimal bd = new BigDecimal("0"); // 李白遇到店的次数 int meetShopTimes ...同时，需要注意的是，BigDecimal的操作相对于基本数据类型的数学运算来说，性能较低，所以在追求效率的同时，也要兼顾精度与性能的平衡。
BigDecimal基本运算介绍
06-25
`BigDecimal` 类是 Java 中用于高精度浮点数计算的关键工具，主要解决 `float` 和 `double` 类型在处理货币、财务等需要精确计算场景时存在的精度问题。`BigDecimal` 的运算方式与基本数据类型有所不同，因为它涉及...
2022年抽象类和接口(1).ppt
11-02
包装类（如`Byte`, `Short`, `Integer`, `Long`, `Float`, `Double`, `Character`, 和 `Boolean`）是Java中的特殊类，它们用于将基本数据类型转换为对象。这在需要使用对象但处理的数据是基本类型时非常有用，例如在...
Java中使用BigDecimal进行浮点数运算
09-04
这是因为Java中的`float`和`double`数据类型基于二进制浮点数表示，这导致它们无法精确表示某些十进制数值。例如，尝试直接进行以下计算： ```java System.out.println(0.05 + 0.01); System.out.println(1.0 - ...
BigDecimal工具类，仅此一篇足以
weixin_39098944的博客
10-13 3059
前言 需要计算的场景绕不过去会使用BigDecimal类，可频繁的判空让代码可读性下降也使代码冗余度增高，不判空又容易报空指针异常，而且有些场景下的计算，结果为空时需要返回null，所以也不可以将将BigDecimal类型的值都初始化为0，会让运算结果产生歧义。为解决上述痛点，于是整理了一个工具类供所有项目一起使用 工具类支持功能 加减乘除、累加、倍数运算。 Integer、Long、Float、Double、String、Object转为BigDecimal。 除法四舍五入并默认保留20位小数点。 Bi
大数据BigDecimal工具类
大白猫的博客
11-11 1160
我们在开发中经常要对数据进行运算，获取对应正确的数值，而double和float这两个本质都是小数点，没办法使用二进制精确的表示，所以他们是不准确的，这个时候就应该使用大数据BigDecimal进行运算了，它可以精确的算出想要的结果。这样就可以实现开发者数据的计算了。
Java中熟练掌握BigDecimal运用-工具类
qq_30713721的博客
12-04 462
浮点数值不适用于无法接受舍入误差的计算当中，比如金融计算，所以建议用BigDecimal计算金额问题。 背景：有些人对BigDecimal接触很少、用得少，对常见的乘法、除法计算有问题，所以封装一下方便高效运用，减少不必要的bug处理时间。
BigDecimal常用方法及手写通用工具类
WLQ0621的博客
09-19 438
项目中操作BigDecimal的工具类，包括加减乘除、四舍五入和比较大小等操作
BigDecimal计算工具类
qq_28392947的博客
04-28 226
【代码】BigDecimal计算工具类。
每天一个知识点 - BigDecimal详解
adobe754的博客
02-23 1279
BigDecimal 可以实现对浮点数的运算，不会造成精度丢失。BigDecimal 是 Java 语言中的一个类，它位于 java.math 包中。BigDecimal 类被设计用来进行高精度的浮点数运算，它提供了一种可以用来进行任意精度的算术运算的方式。BigDecimal 通常用于需要高精度计算的金融领域，例如货币计算。通常情况下，大部分需要浮点数精确运算结果的业务场景(比如涉及到钱的场景)都是通过BigDecimal 来做的
BigDecimal缺点
06-01
2. 不支持自动拆箱和装箱：`BigDecimal`类不能自动转换为基本数据类型，也不能从基本数据类型进行自动转换。这意味着在使用`BigDecimal`类时，你需要手动转换类型。 3. 不支持比较运算符：`BigDecimal`类不支持比较...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值