BigDecimal

最新推荐文章于 2024-03-12 23:46:21 发布

转载最新推荐文章于 2024-03-12 23:46:21 发布 · 1k 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://www.cnblogs.com/zhangyinhua/p/11545305.html

文章标签：

#java

本文详细介绍了Java中BigDecimal的使用。涵盖常用构造函数，指出double类型构造有不可预知性，建议优先用String构造；还介绍常用方法，如加减乘除、大小比较、小数点处理等；说明了格式化操作，以及除法时出现的异常和解决办法；最后给出使用总结和工具类示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

BigDecimal

本文转载自，博客园-LanceToBigData

一、概述

位置	java.math
功能	对超过16位有效位的数进行精确的运算
针对情况	`Double.valueOf(String)` 和`Float.valueOf(String)`会丢失精度

二、常用构造函数

2.1、常用构造函数

创建一个具有参数所指定整数值、双精度值、长整数值、字符串表示的数值的对象

BigDecimal(int)
BigDecimal(double)
BigDecimal(long)
BigDecimal(String)

2.2、使用问题分析

使用示例：

        BigDecimal a =new BigDecimal(1);
        BigDecimal b =new BigDecimal(0.1D);
        BigDecimal c =new BigDecimal(0.1);
        BigDecimal d =new BigDecimal("0.1");

结果示例：

        a: 1
        b: 0.1000000000000000055511151231257827021181583404541015625
        c: 0.1000000000000000055511151231257827021181583404541015625
        d: 0.1

原因分析：

参数类型为double的构造方法的结果有一定的不可预知性。

有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。
这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。
这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

String 构造方法是完全可预知的

写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，通常建议优先使用String构造方法。
当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；
它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。
要获取该结果，请使用static valueOf(double)方法。

三、常用方法详解

3.1、常用方法

BigDecimal对象中的值相加、减、乘、除，返回BigDecimal对象

    add(BigDecimal)
    subtract(BigDecimal)
    multiply(BigDecimal)
    divide(BigDecimal)

将BigDecimal对象中的值转换成整数、单精度数、双精度数、长整数、字符串

    intValue()
    floatValue()
    doubleValue()
    longValue() 
    toString()

3.2、大小比较

java中对BigDecimal比较大小一般用的是bigdemical的compareTo方法

int a = bigdemical.compareTo(bigdemical2)

返回结果分析：

a的取值-1、0、1，分别表示：bigdemical小于、等于、大于bigdemical2

3.3、小数点处理

BigDecimal.setScale()
    
setScale(1) //表示保留一位小数，默认用四舍五入方式
setScale(1,BigDecimal.ROUND_DOWN)  // 直接删除多余的小数位，如2.35会变成2.3
setScale(1,BigDecimal.ROUND_UP)  // 进位处理，2.35变成2.4
setScale(1,BigDecimal.ROUND_HALF_UP)  // 四舍五入，2.35变成2.4
setScaler(1,BigDecimal.ROUND_HALF_DOWN)  // 四舍五入，2.35变成2.3，如果是5则向下舍

参数

scale指的是你小数点后的位数。比如123.456则score就是3，b.scale(),返回的就是3.
roundingMode是小数的保留模式。它们都是BigDecimal中的常量字段,有很多种。比如：BigDecimal.ROUND_HALF_UP表示的就是4舍5入。

例如：

    BigDecimal b = new BigDecimal("18.04445");

    BigDecimal b2 = b.setScale(3, 5);
    BigDecimal b3 = b.setScale(4, 5);
    BigDecimal b4 = b.setScale(4, 4);
    System.out.println(b2);
    System.out.println(b3);
    System.out.println(b4);

结果：

18.044
18.0444
18.0445

3.4 避免以科学计数法格式输出

String s = b.stripTrailingZeros().toPlainString();

四、格式化

由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。

以利用BigDecimal对货币和百分比格式化为例。首先，创建BigDecimal对象，进行BigDecimal的算术运算后，分别建立对货币和百分比格式化的引用，最后利用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){
		String[] decimal = {"3.14", "0", "0.00", "0.001", "0.006", "0.20600"};

        for (int i = 0; i < decimal.length; i++) {
            System.out.println(formatToNumber(new BigDecimal(decimal[i])));
        }
    }

    /**
     * BigDecimal格式化保留2为小数
     * 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。
     * 2.传入的参数等于0，则直接返回字符串"0.00"
     * 3.大于1的小数，直接格式化返回字符串
     */
    public static String formatToNumber(BigDecimal bigDecimal) {
        // 添几个0保留几位
        DecimalFormat df = new DecimalFormat("#.00");
        if (bigDecimal.compareTo(BigDecimal.ZERO) == 0) {
            //return "0.00";
            return "0" + df.format(bigDecimal).toString();
        } else if (bigDecimal.compareTo(BigDecimal.ZERO) > 0 && bigDecimal.compareTo(new BigDecimal(1)) < 0) {
            return "0" + df.format(bigDecimal).toString();
        } else {
            return df.format(bigDecimal).toString();
        }
    }
}

结果为：

五、常见异常

5.1、除法的时候出现异常

java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result

原因分析：

通过BigDecimal的divide方法进行除法时当不整除，出现无限循环小数时，就会抛异常：java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

解决方法：

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

		BigDecimal b1 = new BigDecimal("1.5");
        BigDecimal b2 = new BigDecimal("8");
        System.out.println(b1.divide(b2));
        System.out.println(b1.divide(b2, 2));
        System.out.println(b1.divide(b2, 2, 4));

结果：

        0.1875
        0.2
        0.19

六、总结

6.1、总结

在需要精确的小数计算时再使用BigDecimal
BigDecimal的性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。
尽量使用参数类型为String的构造函数。
BigDecimal都是不可变的（immutable）的，在进行每一次四则运算时，都会产生一个新的对象，所以在做加减乘除运算时要记得要保存操作后的值。

七、工具类

两数运算

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;
    }
}

多数运算

package com.holyjet.tssbService.domain.Service.Common;

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


/**
 * 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精 确的浮点数运算，包括加减乘除和四舍五入。
 */
public class DoubleUtil {

    // 默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;
    /**
     * #.##
     */
    public static final String REG_1 = "#.##";
    /**
     * #,###.##
     */
    public static final String REG_2 = "#,###.##";

    // 这个类不能实例化
    private DoubleUtil() {
    }

    /**
     * 解决double转bigdecimal时出现的精度问题
     *
     * @param v1
     * @return
     */
    public static BigDecimal doubleToBig(double v1) {
        return new BigDecimal(String.valueOf(v1));
    }


    /**
     * 科学记数法转换成字符串
     */
    public static String doubleToStr(double v1) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        return b1.toPlainString();
    }

    /**
     * 科学记数法转换成字符串
     */
    public static String stringToStr(String v1) {
        BigDecimal b1 = new BigDecimal(v1);
        return b1.toPlainString();
    }

    /**
     * 主要用于格式化金额
     *
     * @param v1
     * @return
     */
    public static String format(double v1) {
        NumberFormat numberFormat = new DecimalFormat(REG_2);
        String str = numberFormat.format(v1);
        return str;
    }

    /**
     * 主要用于格式化小数点
     *
     * @param v1
     * @param reg
     * @return
     */
    public static String format(double v1, String reg) {
        NumberFormat numberFormat = new DecimalFormat(reg);
        String str = numberFormat.format(v1);
        return str;
    }


    /**
     * 加法
     */
    public static Double add(double v1, double... v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        for (double vv : v2) {
            BigDecimal b2 = new BigDecimal(Double.toString(vv));
            b1 = b1.add(b2);
        }
        return b1.doubleValue();
    }

    /**
     * 减法
     */
    public static Double sub(double v1, double... v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        for (double vv : v2) {
            BigDecimal b2 = new BigDecimal(Double.toString(vv));
            b1 = b1.subtract(b2);
        }

        return b1.doubleValue();
    }


    /**
     * 乘法
     */
    public static Double mul(double v1, double... v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        for (double vv : v2) {
            BigDecimal b2 = new BigDecimal(Double.toString(vv));
            b1 = b1.multiply(b2);
        }
        return b1.doubleValue();
    }

    /**
     * 除法
     */

    public static Double div(double v1, double... v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        for (double vv : v2) {
            BigDecimal b2 = new BigDecimal(Double.toString(vv));
            b1 = b1.divide(b2, DEF_DIV_SCALE, BigDecimal.ROUND_HALF_UP);
        }
        return b1.doubleValue();
    }

    /**
     * 小数的四舍五入
     */

    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 one = new BigDecimal("1");
        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 两个数比较，获取比较值相对于基准值的大小百分比
     *
     * @param base    基准值
     * @param compare 比较值
     * @return
     */
    public static String getComparePercent(int base, int compare) {
        if (base == compare) {
            return "0%";
        }
        if (compare == 0) {
            return "0%";
        }
        if (base == 0) {
            return compare * 100 + "%";
        }
        NumberFormat numberFormat = NumberFormat.getInstance();
        numberFormat.setMaximumFractionDigits(2); // 设置精确到小数点后2位
        int margin = compare - base;
        String result = numberFormat.format((float) margin / (float) base * 100);
        return result + "%";
    }
}