Java中的金钱陷阱

前言

有多少小伙伴是被标题 骗 吸引进来的呢，我可不是标题党，今天的文章呢确实跟”金钱“有关系。
但是我们说的不是过度追求金钱而掉入陷阱，而是要说一说在Java程序中，各种跟金钱运算有关的陷阱。
日常工作中我们经常会涉及到各种金额这样浮点数的运算。
一旦涉及到金额的运算就必须慎之又慎，一旦有精度丢失，或者其他运算错误就可能造成无可挽回的损失。
一 、 存在的陷阱

这一小节我们先将陷阱列出来，下一小节分别给出解决方案。
我们先来看看到底有哪些坑等着我们去踩
1.1 浮点运算精度丢失陷阱

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         float a = 1.0f - 0.9f;
4.         float b = 0.9f - 0.8f;
6.         System.out.println("a= "+a);
7.         System.out.println("b= "+b);
9.     }
10. }
11. //输出结果
12. a= 0.100000024
13. b= 0.099999964

复制代码

1.2 浮点数等值判断陷阱

① 基本类型与包装类型判断浮点数是否相等

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         float a = 1.0F - 0.9F;
4.         float b = 0.9F - 0.8F;
5.         System.out.println("通过==判断a与b是否相等："+ (a == b));
7.         Float x = Float.valueOf(a);
8.         Float y = Float.valueOf(b);
10.         System.out.println("通过equals方法判断x与y是否相等："+ x.equals(y));
11.     }
12. }
13. //输出结果
14. 通过==判断a与b是否相等false
15. 通过equals方法判断x y是否相等false

复制代码

②BigDecimal类通过equals 方法判断是否相等

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a = new BigDecimal("2");
4.         BigDecimal b = new BigDecimal("2.0");
5.         System.out.println(a.equals(b));
7.     }
8. }
9. //输出结果
10. false

复制代码

1.3 BigDecimal 构造方法中的陷阱

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a = new BigDecimal(0.1f);
4.         
5.         System.out.println("a= "+ a);
6.     }
7. }
8. //输出结果
9. a= 0.100000001490116119384765625

复制代码

1.4 BigDecimal 除法陷阱

如果两数相除无法除尽，抛出 ArithmeticException 异常

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a = new BigDecimal("0.2");
4.         BigDecimal b = new BigDecimal("0.3");
6.         System.out.println(a.divide(b));
7.     }
8. }
9. //输出结果
10. Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
11.         at java.math.BigDecimal.divide(BigDecimal.java:1693)
12.         at com.xiezhr.BigDecimalDemo.main(BigDecimalDemo.java:17)

复制代码

二、避免陷阱

2.1  浮点数运算避坑

① 我们先来看看为什么浮点数(也就是float 和double 关键字定义的数) 运算的时候精度会丢失？
我们直到计算机是以二进制的方式进行数据存储的，在表示一个数字时，宽度时有限的。
十进制的 0.1 转为二进制，得到一个无限循环小数：0.00011… （看不懂的自觉点回去翻一翻大一的《计算机基础》课本）
无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。
这就是为什么浮点数没有办法用二进制精确表示。
②我们怎么来填1.1 中的坑呢？

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a = new BigDecimal("1.0");
4.         BigDecimal b = new BigDecimal("0.9");
5.         BigDecimal c = new BigDecimal("0.9");
6.         BigDecimal d = new BigDecimal("0.8");
8.         System.out.println("a-b = "+a.subtract(b));
9.         System.out.println("c-d = "+c.subtract(d));
10.     }
11. }
12. //输出结果
13. a-b = 0.1
14. c-d = 0.1

复制代码

2.2 浮点数等值判断避坑

日常开发中肯定时免不了比较两个浮点数大小的，这里呢就把1.2中的坑给填上
① 指定一个误差范围，若两个浮点数的差值在误差范围内，则认为两个浮点数时相等的

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         float a = 1.0F - 0.9F;
4.         float b = 0.9F - 0.8F;
5.         //表示10的-6次方
6.         float diff = 1e-6f;
8.         if (Math.abs(a - b )< diff) {
9.             System.out.println("a与b相等");
10.         }
11.     }
12. }
13. //输出结果
14. a与b相等

复制代码

② 使用BigDecimal定义值，再进行运算操作,最后使用compareTo 方法比较

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a = new BigDecimal("1.0");
4.         BigDecimal b = new BigDecimal("0.9");
5.         BigDecimal c = new BigDecimal("0.8");
7.         BigDecimal x = a.subtract(b);
8.         BigDecimal y = b.subtract(c);
10.         if(x.compareTo(y)==0){
11.             System.out.println("x与y相等");
12.         }
13.     }
14. }
15. //输出结果
16. x与y相等

复制代码

2.3 BigDecimal 构造方法避坑

陷阱的产生：

• double的构造方法的结果有一定的不可预知性,
  newBigDecimal(1.0)所创建的实际上等于0.1000000000000000055511151231257827021181583404541015625。
  因为0.1无法准确地表示为 double，传入到构造方法的值不会正好等于 0.1
  
• String 构造方法是完全可预知的
  

​       写入 newBigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1
这里来填1.3中的坑，这里有两种方案
《阿里巴巴Java开发手册》1.4 OOP 规约中提到
⓫ 【强制】 禁止使用构造方法BigDecimal(double)的方式把double值 转换为BigDecimal 对象

说明： BigDecimal(double) 存在精度损失风险，在精确计算或值比较的场景中，可能会导致业务逻辑出现异常。
如：BigDecimal  g = new BigDecimal(0.1f); 实际存储值为：0.100000001490116119384765625

正例： 优先推荐入参为String 的构造方法，或使用BigDecimal 的 valueOf 方法。
此方法内部其实执行了Double  的toString, 而Double 的 toString 按double 的实际能表达的精度对尾数进行了截断。

1. BigDecimal good1 = new BigDecimal("0.1");
2. BigDecimal good2 = BigDecimal.valueOf(0.1);

复制代码

①将BigDecimal(double) ==》BigDecimal(String)

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a = new BigDecimal(Double.toString(0.1));
4.         System.out.println("a=" + a);
5.     }
6. }
7. //输出结果
8. a=0.1

复制代码

②使用BigDecimal类的valueOf 方法

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a =  BigDecimal.valueOf(0.1);
4.         System.out.println("a=" + a);
5.     }
6. }
7. //输出结果
8. a=0.1

复制代码

2.4 BigDecimal 除法避坑

我们使用带有3个参数的divide 方法来填1.4中的坑
BigDecimal.divide(BigDecimal divisor, int scale, RoundingMode roundingMode)  方法的具体使用我们再下一小节中再详细说

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.         BigDecimal a = new BigDecimal("0.2");
4.         BigDecimal b = new BigDecimal("0.3");
5.                 //这里就简单的看作四舍五入就行了
6.         System.out.println("a除以b等于："+ a.divide(b, 2, RoundingMode.HALF_UP));
8.     }
9. }
10. //输出结果
11. a除以b等于：0.67

复制代码

三、BigDecimal 常用方法

• 常用构造方法
  

• 常用方法
  

3.1 加法运算 add

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.        BigDecimal a = new BigDecimal(Double.toString(0.1));
4.        BigDecimal b = BigDecimal.valueOf(0.2);
5.         System.out.println("a + b ="+a.add(b));
6.     }
7. }
8. //输出结果
9. a + b =0.3

复制代码

3.2 减法运算 subtract

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.        BigDecimal a = new BigDecimal(Double.toString(3.5));
4.        BigDecimal b = BigDecimal.valueOf(2.1);
5.         System.out.println("a - b ="+a.subtract(b));
6.     }
7. }
8. //输出结果
9. a - b =1.4

复制代码

3.3 乘法运算 multiply

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.        BigDecimal a = new BigDecimal(Double.toString(2.5));
4.        BigDecimal b = BigDecimal.valueOf(3.26);
5.         System.out.println("a * b ="+a.multiply(b));
6.     }
7. }
8. //输出结果
9. a * b =8.150

复制代码

3.4 除法运算 divide

BigDecimal除法可能出现不能整除的情况,比如 1.2/1.3，
这时会报错java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
这个之前也说过，这里呢再详细说说divide 方法

BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

• divisor : 表示除数
  
• scale: 表示小数点后保留位数
  
• roundingMode: 表示舍入模式。roundingMode是一个枚举类,有八种舍入模式
  我们以0.333 和-0.333保留2位小数为例，采用不同模式后得结果为
  --模式--模式说明图形说明UP远离0的舍入模式【0.333-->0.34   -0.333 -->-0.34】DOWN接近0的舍入模式【0.333-->0.33   -0.333 -->-0.33】CEILINGCEILING英文是天花板的意思，可以理解为向”大“舍入【0.333-->0.34   -0.333 -->-0.33】FLOORFLOOR有地板的意思，可以理解为向”小“舍入【0.333-->0.33  -0.333 -->-0.34】HALF_UP向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入其实就是四舍五入【>=0.5 入，0.5 的入，0.14  0.125-->0.12】UNNECESSARY断言请求的操作具有精确的结果，因此不需要舍入
  

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.             BigDecimal numA = new BigDecimal("1");
4.             BigDecimal numB = new BigDecimal("-1");
5.             BigDecimal numC = new BigDecimal("3");
6.             // 保留两位小数，舍入模式为UP
7.             System.out.println("1/3保留两位小数（UP） = " + numA.divide(numC, 2, RoundingMode.UP));
8.             System.out.println("-1/3保留两位小数（UP） = " + numB.divide(numC, 2, RoundingMode.UP));
9.             // 保留两位小数，舍入模式为DOWN
10.             System.out.println("1/3保留两位小数（DOWN） = " + numA.divide(numC, 2, RoundingMode.DOWN));
11.             System.out.println("-1/3保留两位小数（DOWN） = " + numB.divide(numC, 2, RoundingMode.DOWN));
12.             // 保留两位小数，舍入模式为CEILING
13.             System.out.println("1/3保留两位小数（CEILING） = " + numA.divide(numC, 2, RoundingMode.CEILING));
14.             System.out.println("-1/3保留两位小数（CEILING） = " + numB.divide(numC, 2, RoundingMode.CEILING));
15.             // 保留两位小数，舍入模式为FLOOR
16.             System.out.println("1/3保留两位小数（FLOOR） = " + numA.divide(numC, 2, RoundingMode.FLOOR));
17.             System.out.println("-1/3保留两位小数（FLOOR） = " + numB.divide(numC, 2, RoundingMode.FLOOR));
19.             BigDecimal numD = new BigDecimal("1");
20.             BigDecimal numE = new BigDecimal("-1");
21.             BigDecimal numF = new BigDecimal("8");
22.             // 保留两位小数，舍入模式为HALF_UP
23.             System.out.println("1/8(=0.125)保留两位小数（HALF_UP） = " + numD.divide(numF, 2, RoundingMode.HALF_UP));
24.             System.out.println("-1/8(=0.125)保留两位小数（HALF_UP） = " + numE.divide(numF, 2, RoundingMode.HALF_UP));
25.             // 保留两位小数，舍入模式为HALF_DOWN
26.             System.out.println("1/8(=0.125)保留两位小数（HALF_DOWN） = " + numD.divide(numF, 2, RoundingMode.HALF_DOWN));
27.             System.out.println("-1/8(=0.125)保留两位小数（HALF_DOWN） = " + numE.divide(numF, 2, RoundingMode.HALF_DOWN));
29.             // 保留两位小数，舍入模式为HALF_EVEN
30.             System.out.println("0.54/4(=0.135)保留两位小数（HALF_EVEN） = " + new BigDecimal("0.54").divide(new BigDecimal("4"), 2, RoundingMode.HALF_EVEN));
31.             System.out.println("1/8(=0.125)保留两位小数（HALF_EVEN） = " + numE.divide(numF, 2, RoundingMode.HALF_EVEN));
33.             //UNNECESSARY,会报异常
34.             System.out.println("1/8(=0.125) = " + numE.divide(numF,  RoundingMode.UNNECESSARY));
35.         }
37. }
38. //输出结果
39. 1/3保留两位小数（UP） = 0.34
40. -1/3保留两位小数（UP） = -0.34
41. 1/3保留两位小数（DOWN） = 0.33
42. -1/3保留两位小数（DOWN） = -0.33
43. 1/3保留两位小数（CEILING） = 0.34
44. -1/3保留两位小数（CEILING） = -0.33
45. 1/3保留两位小数（FLOOR） = 0.33
46. -1/3保留两位小数（FLOOR） = -0.34
47. 1/8(=0.125)保留两位小数（HALF_UP） = 0.13
48. -1/8(=0.125)保留两位小数（HALF_UP） = -0.13
49. 1/8(=0.125)保留两位小数（HALF_DOWN） = 0.12
50. -1/8(=0.125)保留两位小数（HALF_DOWN） = -0.12
51. 0.54/4(=0.135)保留两位小数（HALF_EVEN） = 0.14
52. 1/8(=0.125)保留两位小数（HALF_EVEN） = -0.12
53. Exception in thread "main" java.lang.ArithmeticException: Rounding necessary

复制代码

3.5 值转换

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.             BigDecimal a = new BigDecimal(Double.toString(2.3));
4.             BigDecimal b = new BigDecimal(10200000);
6.             System.out.println("BigDecimal转字符串："+a.toString());
7.             System.out.println("BigDecimal转double："+a.doubleValue());
8.             System.out.println("BigDecimal转float："+a.floatValue());
9.             System.out.println("BigDecimal转长整型："+b.longValue());
10.             System.out.println("BigDecimal转int："+b.intValue());
11.     }
13. }
14. //输出结果
15. BigDecimal转字符串：2.3
16. BigDecimal转double：2.3
17. BigDecimal转float：2.3
18. BigDecimal转长整型：10200000
19. BigDecimal转int：10200000

复制代码

3.6 绝对值 abs

1. public class BigDecimalDemo {
2.     public static void main(String[] args) {
3.             BigDecimal a = new BigDecimal(Double.toString(2.35));
4.             BigDecimal b = BigDecimal.valueOf(-2.35);
6.             System.out.println("a的绝对值是：" + a.abs());
7.             System.out.println("b的绝对值是：" + b.abs());
8.     }
10. }
11. //输出结果
12. a的绝对值是：2.35
13. b的绝对值是：2.35

复制代码

3.7 等值比较

《阿里巴巴Java开发手册》第一章 1.4 OOP规约 中提到
❾【强制】  浮点数之间的等值判断，基本数据类型不能用==进行比较，包装数据类型不能用equals方法判断。

说明： 浮点数采用“尾数+阶码”的编码方式，类似于科学计数法的“有效数字+指数“ 的表示方式。
二级制无法精确表示大部分十进制小数，具体原理参考《码出高效，Java开发手册》

[code]反例：    float a = 1.0f - 0.9f;    float b = 0.9f - 0.8 f;                if(a==b){        //预期进入此代码块，执行其他业务逻辑        //但事实上a==b 的结果为false    }        Float x = Float.valueOf(a);        Float y = Float.valueOf(b);        if(x.equals(y)){        // 预期进入此代码块，执行其他业务逻辑        //但事实上x.equals(y)的结果为false    }正例：    1）指定一个误差范围，若两个浮点数的差值在此范围之内，则认为是相等的。    float a = 1.0f - 0.9f;    float b = 0.9f - 0.8f;        //10的-6次方        float diff = 1e-6f;        if(Math.abs(a-b)