java.math.BigDecimal类详解

阅读量：

一、BigDecimal概述

Java在java.math包中提供了接口类BigDecimal来实现高精度的大数运算功能。与双精度浮点型变量double相比，在实际编程开发中我们常常会遇到需要处理超16位有效数字的情况。通常情况下，在不需要严格控制精度的小数值运算场景下我们可以使用浮点型数据类型float和double来进行处理。然而需要注意的是将字符串转换为float或double类型时会损失部分精度信息因此在需要精确计算结果的应用场景下必须选择更高精度的数据类型即BigDecimal来进行操作以保证计算结果的准确性

BigDecimal类所生成的对象具有独特性，在这种情况下我们无法直接使用传统的加减乘除等算术运算符对这些对象执行常规计算操作；相反地需要调用其对应的专用方法来进行相应的数值处理操作。需要注意的是在这些方法中所有的操作参数都必须是BigDecimal类型的实例；此外构造器作为一种特殊的成员函数其主要功能就是负责实例化一个新对象并赋予它必要的属性值这一过程通常会结合具体的参数配置以满足特定的应用需求。

二、BigDecimal常用构造函数

2.1、常用构造函数

BigDecimal(int) 生成一个对象其内部存储了由该int值确定的内容
BigDecimal(double) 生成一个对象其内部存储了由该double值确定的内容
BigDecimal(long) 生成一个对象其内部存储了由该long值确定的内容
BigDecimal(String) 生成一个对象其内部存储了由该String表示的数值内容

2.2、使用问题分析

使用示例：

复制代码

    BigDecimal a =new BigDecimal(0.1);
    System.out.println("a values is:"+a);
    System.out.println("=====================");
    BigDecimal b =new BigDecimal("0.1");
    System.out.println("b values is:"+b);
    
    
      
      
      
      
      
    
    代码解读

结果示例：

复制代码

    a values is:0.1000000000000000055511151231257827021181583404541015625
    =====================
    b values is:0.1
    
    
      
      
      
    
    代码解读

原因分析：

1）当参数类型为double时，在构造BigDecimal对象时会引入不确定因素。有些人可能会认为在Java语言中使用new BigDecimal(0.1)会精确生成一个等于0.1（非标度值为1）的BigDecimal对象（即其标度为1），但实际上该对象等于0.100000000000000...（具体数值略去）。这是因为数字系统内部存储方式的原因：在二进制系统中无法精确表示十进制的小数值（或者说对于该情况来说）。因此，在这种情况下输入到构造方法中的值不会正好等于预期中的数值。

2）使用String作为参数来构造BigDecimal对象是一种完全可预知的方式：将new BigDecimal("0.1")将创建一个精确等于预期值的BigDecimal对象（即其标度为1）。基于这一特点的原因表明，默认建议优先采用String构造方法。

3）当需要将double作为BigDecimal源时，请注意：该构造方法会提供一个精确转换；它不会与以下操作结果相同：先调用Double.toString(double)，然后用新生成的字符串来构造BigDecimal对象。要获得与前者相同的结果，请使用static valueOf(double)方法。

三、BigDecimal常用方法详解

3.1、常用方法

add(BigDecimal)
BigDecimal对象中的值相加，返回BigDecimal对象
subtract(BigDecimal)
BigDecimal对象中的值相减，返回BigDecimal对象
multiply(BigDecimal)
BigDecimal对象中的值相乘，返回BigDecimal对象
divide(BigDecimal)
BigDecimal对象中的值相除，返回BigDecimal对象
toString()
将BigDecimal对象中的值转换成字符串
doubleValue()
将BigDecimal对象中的值转换成双精度数
floatValue()
将BigDecimal对象中的值转换成单精度数
longValue()
将BigDecimal对象中的值转换成长整数
intValue()
将BigDecimal对象中的值转换成整数

3.2、BigDecimal大小比较

在Java语言中进行BigDecimal数值比较时通常采用的方法是调用compareTo()函数

复制代码

    int a = bigdemical.compareTo(bigdemical2)
    
    
      
    
    代码解读

返回结果分析：

复制代码

    a = -1,表示bigdemical小于bigdemical2；
    a = 0,表示bigdemical等于bigdemical2；
    a = 1,表示bigdemical大于bigdemical2；
    
    
      
      
      
    
    代码解读

举例：a大于等于b

复制代码

    new bigdemica(a).compareTo(new bigdemical(b)) >= 0
    
    
      
    
    代码解读

四、BigDecimal格式化

由于NumberFormat类中的format()方法允许将BigDecimal对象用作其参数之一，在处理涉及超过16位有效数字的金额、比例及通用数值时具有显著控制能力**。例如，在处理货币与百分比时就可实现这种控制效果。具体操作如下：首先创建一个合适的BigDecimal对象，在完成对其各项算术运算之后分别生成相应的引用以实现不同类型的格式化需求；最后将这些引用中的数据传递给**format()**方法以获取最终结果。

复制代码

    NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用
    NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用
    percent.setMaximumFractionDigits(3); //百分比小数点最多3位
    
    BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
    BigDecimal interestRate = new BigDecimal("0.008"); //利率
    BigDecimal interest = loanAmount.multiply(interestRate); //相乘
    
    System.out.println("贷款金额:\t" + currency.format(loanAmount));
    System.out.println("利率:\t" + percent.format(interestRate));
    System.out.println("利息:\t" + currency.format(interest));
    
    
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

结果：

复制代码

    贷款金额: ￥15,000.48 利率: 0.8% 利息: ￥120.00
    
    
      
    
    代码解读

BigDecimal格式化保留2为小数，不足则补0：

复制代码

    public class NumberFormat {
    
    public static void main(String[] s){
        System.out.println(formatToNumber(new BigDecimal("3.435")));
        System.out.println(formatToNumber(new BigDecimal(0)));
        System.out.println(formatToNumber(new BigDecimal("0.00")));
        System.out.println(formatToNumber(new BigDecimal("0.001")));
        System.out.println(formatToNumber(new BigDecimal("0.006")));
        System.out.println(formatToNumber(new BigDecimal("0.206")));
    }
    /** * @desc 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。
     * 2.传入的参数等于0，则直接返回字符串"0.00"
     * 3.大于1的小数，直接格式化返回字符串
     * @param obj传入的小数
     * @return
     */
    public static String formatToNumber(BigDecimal obj) {
        DecimalFormat df = new DecimalFormat("#.00");
        if(obj.compareTo(BigDecimal.ZERO)==0) {
            return "0.00";
        }else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){
            return "0"+df.format(obj).toString();
        }else {
            return df.format(obj).toString();
        }
    }
    }
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

结果为：

复制代码

五、BigDecimal常见异常

5.1、除法的时候出现异常

复制代码

    java.lang.ArithmeticException: Non-terminating decimal expansion; 
    no exact representable decimal result
    
    
      
      
    
    代码解读

在使用BigDecimal执行除法运算时，在无法整除的情况下遇到无法终止的小数情况会触发ArithmeticException异常（具体信息为：无法终止的小数展开以及无法精确表示为十进制的结果）。应对策略如下：

divide方法设置精确的小数点，如：divide(xxxxx,2)

六、BigDecimal总结

6.1

总结指出，在执行精确的小数计算时应采用BigDecimal。需要注意的是，相对于double和float来说，BigDecimal的运算效率较低；这一现象尤其在涉及复杂或大规模计算的任务中表现得更为明显。因此，在大多数情况下，并不需要依赖BigDecimal来完成一般的数值计算任务。推荐优先选择带有String参数版本的构造函数来初始化 BigDecimal对象；值得注意的是，所有创建好的 BigDecimal 实例都是不可变对象（immutable objects）。每次执行基本算术运算（如加减乘除）时都会生成新的实例；因此，在完成这些基本算术操作后必须确保保存结果值。

6.2、工具类推荐

复制代码

    package com.vivo.ars.util;
    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;
    }
    }
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

全部评论 (0)

还没有任何评论哟~

java.math.BigDecimal类详解

一、BigDecimal概述 Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际...

java.math.BigDecimal类multiply用法

java.math.BigDecimal.multiplyBigIntegerval返回一个BigInteger，其值是thisval 查阅java8API手册 NumberComparableBig...

java.math.BigDecimal

java.math.BigDecimal 一、定义不可变的、任意精度的有符号十进制数。表示的数字的值BigDecimal是unscaledValue×10^scale。 BigDecimal类使用户...

8_全面分析java.math.BigDecimal

1、BigDecimal继承接口以及实现类 publicclassBigDecimal extendsNumber implementsComparable<BigDecimal 2、对于scale的...

Unsafe类详解

Java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作。 Unsafe类在sun.misc包下，不属于Java标准。很多Java的基础类库，包括一些被广泛使用...

InputStreamReader类详解

咦咦咦，各位小可爱，我是你们的好伙伴——bug菌，今天又来给大家普及JavaSE相关知识点了，别躲起来啊，听我讲干货还不快点赞，赞多了我就有动力讲得更嗨啦！所以呀，养成先点赞后阅读的好习惯，别被干货淹...

是否确定退出登录?

java.math.BigDecimal类详解

一、BigDecimal概述

二、BigDecimal常用构造函数

2.1、常用构造函数

2.2、使用问题分析

三、BigDecimal常用方法详解

3.1、常用方法

3.2、BigDecimal大小比较

四、BigDecimal格式化

五、BigDecimal常见异常

六、BigDecimal总结

6.1

6.2、工具类推荐

全部评论 (0)

相关文章推荐

java.math.BigDecimal类详解

java.math.BigDecimal类multiply用法

java.math.BigDecimal

8_全面分析java.math.BigDecimal

Unsafe类详解

InputStreamReader类详解

BufferWriter类详解

BufferWriter类详解

BufferWriter类详解

BufferWriter类详解