目录
3.java.math.BigDecimal下的三个toString方法的区别及用法
踩坑五：使用BigDecimal进行计算时参数不能为NULL
踩坑六：使用BigDecimal进行除法计算时被除数不能为0
一、BigDecimal简介
BigDecimal是Java在java.math包中提供的线程安全的API类，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。
BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。
二、常用方法
A、BigDecimal常用构造方法
| 方法 | 含义 |
| BigDecimal(int val) | 创建一个具有参数所指定整数值的对象。 |
| BigDecimal(double val) | 创建一个具有参数所指定双精度值的对象。 不推荐使用,因为存在精度丢失问题 |
| BigDecimal(long val) | 创建一个具有参数所指定长整数值的对象。 |
| BigDecimal(String val) | 创建一个具有参数所指定以字符串表示的数值的对象。 推荐使用 |
B、BigDecimal常用方法
注意：BigDecimal进行运算时必须要保证对象本身不能是null，否则就会抛空指针异常。
| 方法 | 含义 |
| add(BigDecimal) | BigDecimal对象中的值相加，返回BigDecimal对象 |
| subtract(BigDecimal) | BigDecimal对象中的值相减，返回BigDecimal对象 |
| multiply(BigDecimal) | BigDecimal对象中的值相乘，返回BigDecimal对象 |
| divide(BigDecimal) | BigDecimal对象中的值相除，返回BigDecimal对象。 该方法可能会遇到无限精度问题，会抛出异常，使用时需注意。详细见下方的无限精度的坑 |
| abs() | 将BigDecimal对象中的值转换成绝对值 |
| doubleValue() | 将BigDecimal对象中的值转换成双精度数 |
| floatValue() | 将BigDecimal对象中的值转换成单精度数 |
| longValue() | 将BigDecimal对象中的值转换成长整数 |
| intValue() | 将BigDecimal对象中的值转换成整数 |
| compareTo(BigDecimal val) | 比较大小，返回int类型。0（相等） 1（大于） -1（小于） |
| toString() | 有必要时使用科学计数法。 |
| toPlainString() | 不使用任何指数。 推荐使用 |
| toEngineeringString() | 有必要时使用工程计数法。 工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数 |
| max(BigDecimal val) | 两值比较，返回最大值 |
| negate() | 求相反数，正变负，负变正 |
| pow(int n) | 求乘方，如BigDecimal.valueOf(2).pow(3)的值为8 |
二、代码实现
A、加减乘除
1.创建两个BigDecimal对象
BigDecimal a = new BigDecimal(10);
BigDecimal b = new BigDecimal(20);2.BigDecimal相加
//BigDecimal相加
BigDecimal addition = a.add(b);
System.out.println("BigDecimal相加结果为:"+addition);结果:
3.BigDecimal相减
//BigDecimal相减
BigDecimal subtract = a.subtract(b);
System.out.println("BigDecimal相减结果为:"+subtract);结果:
4.BigDecimal相乘
//BigDecimal相乘
BigDecimal multiply = a.multiply(b);
System.out.println("BigDecimal相乘结果为:"+multiply);结果：
5.BigDecimal相除
//BigDecimal相除
BigDecimal divide = a.divide(b);
System.out.println("BigDecimal相除结果为:"+divide);结果：
相除报错
原因：JAVA中如果BigDecimal做除法的时候，结果是无限循环小数时，就会抛出以上异常。
例子:比如10除3
解决方法:
//说明
BigDecimal divide = 除数.divide(被除数,保留几位小数,小数位数的截取方式);小数位的截取方式
ROUND_UP 始终对前一位加1 只入不舍
ROUND_DOWN 始终不对小数进行改变 只舍不入
ROUND_CEILING 如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同;如果为负，则舍入行为与 ROUND_DOWN 相同。
ROUND_FLOOR 如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同;如果为负，则舍入行为与 ROUND_UP 相同。
ROUND_HALF_UP 四舍五入
ROUND_HALF_DOWN 五舍六入
ROUND_HALF_EVEN 如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同;如果为偶数，则舍入行为与 ROUND_HALF_DOWN 相同。BigDecimal的八种舍入模式
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则向下舍
setScaler(1,BigDecimal.ROUND_CEILING)接近正无穷大的舍入
setScaler(1,BigDecimal.ROUND_FLOOR)接近负无穷大的舍入，数字>0和ROUND_UP作用一样，数字<0和ROUND_DOWN作用一样
setScaler(1,BigDecimal.ROUND_HALF_EVEN)向最接近的数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。B、转换
1.定义一个 数值
BigDecimal a = new BigDecimal(10.5);2.转换
//转换成双精度 double类型
double v = a.doubleValue();
System.out.println("转换成双精度结果为:"+v);
//转换成单精度 float类型
float f = a.floatValue();
System.out.println("转换成单精度结果为:"+v);
//转换成长整形 long 类型
long l = a.longValue();
System.out.println("转换成长整形结果为:"+v);
//转换成整形 int 类型
int i = a.intValue();
System.out.println("转换成整形结果为:"+v);结果
3.java.math.BigDecimal下的三个toString方法的区别及用法
toPlainString() : 不使用任何指数。
toString() ：有必要时使用科学计数法。
toEngineeringString()：有必要时使用工程计数法。 工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数
| 不使用指数 | 科学记数法 | 工程记数法 |
| 0.0001 | 0.0001 | 0.0001 |
| 0.0000001 | 1E-7 | 100E-9 |
toString()、toEngineeringString()方法在某些时候会使用科学计数法或工程计数法，不是所有情况都会使用科学计数法或工程计数法的
对于一个数值可能很小的BigDecimal对象来说，使用toString()可能由于打印的数值太小而打印其科学计数法表示，而使用toPlainString()才能打印完整的数值。
C、次方、绝对值、负数
1.定义两个BigDecimal对象
BigDecimal a = new BigDecimal(3);
BigDecimal b = new BigDecimal(-20);2.次方
BigDecimal pow = a.pow(3);
System.out.println("a的3次方为:"+pow);结果
3.绝对值
BigDecimal abs = b.abs();
System.out.println("b的绝对值为:"+abs);结果
4.负数
BigDecimal negate = a.negate();
System.out.println("a的负数为:"+negate);
BigDecimal negate1 = b.negate();
System.out.println("b的负数为:"+negate1);结果
D、比较大小
1.定义两个BigDecimal对象
BigDecimal a = new BigDecimal (101);
BigDecimal b = new BigDecimal (111);2.比较
a.使用compareTo方法比较a和b
代码
// 使用compareTo方法比较a和b
// 注意：a、b均不能为null，否则会报空指针异常
if (a.compareTo(b) == -1) {
// 如果a小于b，输出" a小于b"
System.out.println("a小于b");
}
if (a.compareTo(b) == 0) {
// 如果a等于b，输出" a等于b"
System.out.println("a等于b");
}
if (a.compareTo(b) == 1) {
// 如果a大于b，输出" a大于b"
System.out.println("a大于b");
}
if (a.compareTo(b) > -1) {
// 如果a大于等于b，输出" a大于等于b"
System.out.println("a大于等于b");
}
if (a.compareTo(b) < 1) {
// 如果a小于等于b，输出" a小于等于b"
System.out.println("a小于等于b");
}结果
解释说明
compareTo 方法用于比较两个 BigDecimal 对象的大小。
返回值：
-1：表示调用者（a）小于参数（b）。
0：表示两个对象相等。
1：表示调用者大于参数。
代码逻辑
比较 a 和 b：
第一个条件检查 a 是否小于 b。
第二个条件检查 a 是否等于 b。
第三个条件检查 a 是否大于 b。
第四个条件检查 a 是否大于等于 b。
第五个条件检查 a 是否小于等于 b。
b.使用max()比较a和b
代码
// 使用max方法比较a和b，返回较大的值
BigDecimal max = a.max(b);
// 输出较大的值
System.out.println("a和b比较,比较大的值为:" + max);结果
解释说明
a.max(b)：该方法返回 a 和 b 中的较大值。
System.out.println(...)：打印出比较后的结果，显示哪个值更大。
三、常见问题总结
踩坑一：创建 BigDecimal精度丢失的坑
在BigDecimal 中提供了多种创建方式，可以通过new 直接创建，也可以通过 BigDecimal#valueOf 创建。这两种方式使用不当，也会导致精度问题。如下：
public static void main(String[] args) throws Exception {
BigDecimal b1= new BigDecimal(0.1);
System.out.println(b1);
BigDecimal b2= BigDecimal.valueOf(0.1);
System.out.println(b2);
BigDecimal b3= BigDecimal.valueOf(0.111111111111111111111111111234);
System.out.println(b3);
}执行结果：
0.1000000000000000055511151231257827021181583404541015625
0.1
0.1111111111111111上面示例中两个方法都传入了double类型的参数0.1但是 b1 还是出现了精度的问题。造成这种问题的原因是 0.1 这个数字计算机是无法精确表示的，给 BigDecimal 的时候就已经丢精度了，而BigDecimal#valueOf 的实现却完全不同。
如下源码所示，BigDecimal#valueOf 中是把浮点数转换成了字符串来构造的BigDecimal，因此避免了问题。
public static BigDecimal valueOf(double val) {
return new BigDecimal(Double.toString(val));
}结论：
- 第一，在使用BigDecimal构造函数时，尽量传递字符串而非浮点类型；
- 第二，如果无法满足第一条，则可采用BigDecimal#valueOf方法来构造初始化值。但是valueOf受double类型精度影响，当传入参数小数点后的位数超过double允许的16位精度还是可能会出现问题的
踩坑二：等值比较的坑
一般在比较两个值是否相等时，都是用equals 方法，但是，在BigDecimal 中使用equals可能会导致结果错误，BigDecimal 中提供了 compareTo 方法，在很多时候需要使用compareTo 比较两个值。如下所示：
public static void main(String[] args){
BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("1.00");
System.out.println(b1.equals(b2));
System.out.println(b1.compareTo(b2));
}执行结果：
false
0出现此种结果的原因是，equals不仅比较了值是否相等，还比较了精度是否相同。示例中，由于两个值的精度不同，所有结果也就不相同。而 compareTo 是只比较值的大小。返回的值为-1（小于），0（等于），1（大于）。
结论
- 如果比较两个BigDecimal值的大小，采用其实现的compareTo方法；
- 如果严格限制精度的比较，那么则可考虑使用equals方法。
踩坑三：无限精度的坑
BigDecimal 并不代表无限精度，当在两个数除不尽的时候，就会出现无限精度的坑，如下所示：
public static void main(String[] args){
BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("3.0");
b1.divide(b2);
}执行结果：
在官方文档中对该异常有如下说明：
If the quotient has a nonterminating decimal expansion and the operation is specified to return an exact result, an ArithmeticException is thrown. Otherwise, the exact result of the division is returned, as done for other operations.
大致意思就是，如果在除法（divide）运算过程中，如果商是一个无限小数（如 0.333…），而操作的结果预期是一个精确的数字，那么将会抛出ArithmeticException异常。
此种情况，只需要在使用 divide方法时指定结果的精度即可：
public static void main(String[] args){
BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("3.0");
System.out.println(b1.divide(b2,2, RoundingMode.HALF_UP));//0.33
}结论：
- 在使用BigDecimal进行（所有）运算时，尽量指定精度和舍入模式。
注：在上文代码实现时，也有详细的解释
踩坑四：BigDecimal三种字符串输出的坑
在BigDecimal 转换成字符串时，有可能输出非你预期的结果。如下所示：
public static void main(String[] args){
BigDecimal bg = new BigDecimal("1E11");
System.out.println(bg.toString()); // 1E+11
System.out.println(bg.toPlainString()); // 100000000000
System.out.println(bg.toEngineeringString()); // 100E+9
}执行结果：
1E+11
100000000000
100E+9可以看到三种方式输出的结果可能都不相同，可能这个并不是预期的结果 ，BigDecimal 有三个方法可以转为相应的字符串类型，切记不要用错：
以下内容介绍java.math.BigDecimal下的三个toString方法的区别及用法
toPlainString() : 不使用任何指数。
toString() ：有必要时使用科学计数法。
toEngineeringString()：有必要时使用工程计数法。 工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数踩坑五：使用BigDecimal进行计算时参数不能为NULL
在使用BigDecimal类型进行计算时，进行加、减、乘、除、比较大小时，一定要保证参与计算的两个值不能为空，否则会抛出java.lang.NullPointerException异常。
代码示例：
BigDecimal b1 = new BigDecimal("1");
BigDecimal b2 = null;
System.out.println("相加："+b2.add(b1));结果：
踩坑六：使用BigDecimal进行除法计算时被除数不能为0
代码示例：
BigDecimal b1 = new BigDecimal("1");
BigDecimal b2 = new BigDecimal("0");
System.out.println(b1.divide(b2));执行结果：
踩坑七：执行顺序不能调换（乘法交换律失效）
乘法满足交换律是一个常识，但是在计算机的世界里，会出现不满足乘法交换律的情况；
代码示例：
BigDecimal b1 = BigDecimal.valueOf(1.0);
BigDecimal b2 = BigDecimal.valueOf(3.0);
BigDecimal b3 = BigDecimal.valueOf(3.0);
System.out.println(b1.divide(b2, 2, RoundingMode.HALF_UP).multiply(b3)); // 0.990
System.out.println(b1.multiply(b3).divide(b2, 2, RoundingMode.HALF_UP)); // 1.00执行结果：
执行顺序交换后，产生的结果可能不同，会导致一定的问题，使用顺序建议先乘后除。
工具类
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;
}
}