BigDecimal 想必我们都不陌生，涉及到金额的地方基本上都是用这个数据类型进行处理，那一般你用的是哪个数据类型？精度是如何处理的？有没有碰到过坑？
1、BigDecimal 的概述
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。 BigDecimal所创建的是对象故我们不能使用传统的＋，-,×，÷等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。
更具体的用法请重学Java基础哈哈哈！
2、阿里巴巴开发规范
1、构造与比较
【强制】BigDecimal的等值比较应使用compareTo()方法，而不是equals()方法。
说明：equals()方法会比较值和精度（1.0与1.00返回结果为false），而compareTo()则会忽略精度
2、浮点数之间的判断
【强制】浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用equals来判断
说明：浮点数采用“尾数 阶码”的编码格式，似于科学计数法癿“有效数字 指数”的表示方式。二进制无法精确表示大部分的十进制小数，具体原理参考《码出高效》
反例：
代码语言：javascript复制float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
if (a == b) {
// 预期进入此代码块，执行其他逻辑
// 但事实上 a==b 的结果为 false
}
Float x = Float.valueOf(a);
Float y = Float.valueOf(b);
if (x.equals(y)) {
// 预期进入此代码块，执行其他逻辑
// 但事实上 equals 的结果为 false
}
正确的如下：
指定一个诨差范围，两个浮点数的差值在此范围之内，则认为是相等的。
代码语言：javascript复制float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
float diff = 1e-6f;
if (Math.abs(a - b) < diff){
System.out.println("true");
}
使用BigDecimal来定义值，再进行浮点数之间的运算
代码语言：javascript复制BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b);
BigDecimal y = b.subtract(c);
if (x.equals(y)) {
System.out.println("true");
}
11.【强制】禁止使用构造方法BigDecimal(double)的方式把double 值转化为BigDecimal 对象。
说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。
如：BigDecimal g = new BigDecimal(0.1f); 实际的存储值为：0.10000000149
正例：优先推荐入参为 String 的构造方法，或使用 BigDecimal 的valueOf 方法，此方法内部其实执行了
Double 的 toString，而 Double的toString 按 double 的实际能表达的精度对尾数迕行了截断。
代码语言：javascript复制BigDecimal recommend1 = new BigDecimal("0.1");
BigDecimal recommend2 = BigDecimal.valueOf(0.1);
3、案例分析
1、实体类与SQL
代码语言：javascript复制private BigDecimal amount;
image-20240801222012609
2、分析
代码语言：javascript复制public class BigDecimal_BugDemo
{
public static void main(String[] args)
{
//doubleDemo(); //double类型精度丢失
//===================BigDecimal===================
//m1();
//m2();
m3();
//m4();
}
/**
* 科学计数法相关
*
*/
private static void m4()
{
BigDecimal amount1 = BigDecimal.valueOf(1234567890123456789.3141592631415926);
System.out.println(amount1); //科学计数法: 1.23456789012345677E 18
System.out.println(amount1.toString()); //科学计数法: 1.23456789012345677E 18
System.out.println(amount1.toPlainString()); //不使用科学计数法
System.out.println();
BigDecimal amount2 = new BigDecimal("1234567890123456789.3141592631415926");
System.out.println(amount2);
System.out.println(amount2.toString());
System.out.println(amount2.toPlainString());
}
/**除法商的结果,需要指定精度
* BigDecimal 的 8 种 RoundingMode（舍入模式）
* https://my.oschina.net/u/3644969/blog/4927776
*
* ROUND_HALF_UP
* 向 “最接近” 的数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
* 如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同；否则舍入行为与 ROUND_DOWN 相同。
* 这种模式也就是我们常说的我们的 “四舍五入”。
*
* ROUND_HALF_DOWN
*
* 向 “最接近” 的数字舍入，如果与两个相邻数字的距离相等，则为向下舍入的舍入模式。
* 如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同；否则舍入行为与 ROUND_DOWN 相同。
* 这种模式也就是我们常说的我们的 “五舍六入”。
*/
private static void m3()
{
BigDecimal amount1 = new BigDecimal("2.0");
BigDecimal amount2 = new BigDecimal("3.0");
//System.out.println(amount1.divide(amount2)); //Non-terminating decimal expansion; no exact representable decimal result.
//我们该如何处理？
System.out.println(amount1.divide(amount2, 2,RoundingMode.HALF_UP)); //这种模式也就是我们常说的我们的 “四舍五入”。
}
/**参考阿里手册
* 10.【强制】BigDecimal的等值比较应使用compareTo() 方法，而不是equals() 方法。
*/
private static void m2()
{
BigDecimal amount1 = new BigDecimal("0.9");
BigDecimal amount2 = new BigDecimal("0.90");
//给同学们看一下equals源码,它有个精度范围比较导致出错
System.out.println("equals比较结果：" amount1.equals(amount2));
System.out.println("compareTo比较结构：" amount1.compareTo(amount2));
}
/**
* 参考阿里手册
* 12.【强制】禁止使用构造方法BigDecimal(double) 的方式把double值转化为BigDecimal对象
* 优先推荐入参为String的构造方法，或使用BigDecimal的valueOf方法，此方法内部其实执行了Double的
* toString，而Double的toString按double的实际能表达的精度对尾数进行了截断。
*/
private static void m1()
{
//给同学们看一下new BigDecimal()源码
BigDecimal amount1 = new BigDecimal(0.03);
BigDecimal amount2 = new BigDecimal(0.02);
//12.【强制】禁止使用构造方法BigDecimal(double) 的方式把double值转化为BigDecimal对象,非要转那？
System.out.println("amount1: " amount1);
System.out.println("amount2: " amount2);
//应该等于0.01
System.out.println(amount1.subtract(amount2));
System.out.println();
//优先推荐入参为String的构造方法
BigDecimal amount3 = new BigDecimal("0.03");
BigDecimal amount4 = new BigDecimal("0.02");
//应该等于0.01
System.out.println(amount3.subtract(amount4));
System.out.println();
//使用BigDecimal的valueOf方法,给同学们看一下valueOf源码
BigDecimal amount5 = BigDecimal.valueOf(0.03);
BigDecimal amount6 = BigDecimal.valueOf(0.02);
//应该等于0.01
System.out.println(amount5.subtract(amount6));
}
/**
* why
* double类型的两个参数相减会转换成二进制，
* 因为double有效位数为16位这就会出现存储小数位数不够的情况，这种情况下就会出现误差
*/
private static void doubleDemo()
{
double amount1 = 0.03;
double amount2 = 0.02;
//执行结果会是多少？
System.out.println(amount1 - amount2);
}
}
m1()方法的结果如下：
代码语言：javascript复制amount1: 0.0299999999999999988897769753748434595763683319091796875
amount2: 0.0200000000000000004163336342344337026588618755340576171875
0.0099999999999999984734433411404097569175064563751220703125
0.01
0.01
m2()方法的结果如下：
代码语言：javascript复制equals比较结果：false
compareTo比较结构：0
m3()方法的结果如下：
代码语言：javascript复制0.67
m4()方法的结果如下：
代码语言：javascript复制1.2345678901234568E 18
1.2345678901234568E 18
1234567890123456800
1234567890123456789.3141592631415926
1234567890123456789.3141592631415926
1234567890123456789.3141592631415926
总结：
- 当使用Float/Double这些浮点数据时，会丢失精度，String/int类型就不会，BigDecimal(double)存在精度损失风险
- 等值比较应使用compareTo()方法，equals()方法会比较值和精度（1.0与1.00返回结果为false），而compareTo()则会忽略精度
- 除法商的结果需要指定精度
- 科学计数法的使用问题
4、编码最佳实践
代码语言：javascript复制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;
}
}
