有多少小伙伴是被标题 骗 吸引进来的呢,我可不是标题党,今天的文章呢确实跟”金钱“有关系。
但是我们说的不是过度追求金钱而掉入陷阱,而是要说一说在Java程序中,各种跟金钱运算有关的陷阱。
日常工作中我们经常会涉及到各种金额这样浮点数的运算。
一旦涉及到金额的运算就必须慎之又慎,一旦有精度丢失,或者其他运算错误就可能造成无可挽回的损失。
这一小节我们先将陷阱列出来,下一小节分别给出解决方案。
我们先来看看到底有哪些坑等着我们去踩
public class BigDecimalDemo { public static void main(String[] args) { float a = 1.0f - 0.9f; float b = 0.9f - 0.8f; System.out.println("a= "+a); System.out.println("b= "+b); } } //输出结果 a= 0.100000024 b= 0.099999964
① 基本类型与包装类型判断浮点数是否相等
public class BigDecimalDemo { public static void main(String[] args) { float a = 1.0F - 0.9F; float b = 0.9F - 0.8F; System.out.println("通过==判断a与b是否相等:"+ (a == b)); Float x = Float.valueOf(a); Float y = Float.valueOf(b); System.out.println("通过equals方法判断x与y是否相等:"+ x.equals(y)); } } //输出结果 通过==判断a与b是否相等false 通过equals方法判断x y是否相等false
②BigDecimal
类通过equals
方法判断是否相等
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal("2"); BigDecimal b = new BigDecimal("2.0"); System.out.println(a.equals(b)); } } //输出结果 false
BigDecimal
构造方法中的陷阱public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal(0.1f); System.out.println("a= "+ a); } } //输出结果 a= 0.100000001490116119384765625
BigDecimal
除法陷阱如果两数相除无法除尽,抛出 ArithmeticException
异常
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal("0.2"); BigDecimal b = new BigDecimal("0.3"); System.out.println(a.divide(b)); } } //输出结果 Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result. at java.math.BigDecimal.divide(BigDecimal.java:1693) at com.xiezhr.BigDecimalDemo.main(BigDecimalDemo.java:17)
① 我们先来看看为什么浮点数(也就是float
和double
关键字定义的数) 运算的时候精度会丢失?
我们直到计算机是以二进制的方式进行数据存储的,在表示一个数字时,宽度时有限的。
十进制的 0.1 转为二进制,得到一个无限循环小数:0.00011… (看不懂的自觉点回去翻一翻大一的《计算机基础》课本)
无限循环的小数存储在计算机时,只能被截断,所以就会导致小数精度发生损失的情况。
这就是为什么浮点数没有办法用二进制精确表示。
②我们怎么来填1.1 中的坑呢?
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal("1.0"); BigDecimal b = new BigDecimal("0.9"); BigDecimal c = new BigDecimal("0.9"); BigDecimal d = new BigDecimal("0.8"); System.out.println("a-b = "+a.subtract(b)); System.out.println("c-d = "+c.subtract(d)); } } //输出结果 a-b = 0.1 c-d = 0.1
日常开发中肯定时免不了比较两个浮点数大小的,这里呢就把1.2中的坑给填上
① 指定一个误差范围,若两个浮点数的差值在误差范围内,则认为两个浮点数时相等的
public class BigDecimalDemo { public static void main(String[] args) { float a = 1.0F - 0.9F; float b = 0.9F - 0.8F; //表示10的-6次方 float diff = 1e-6f; if (Math.abs(a - b )< diff) { System.out.println("a与b相等"); } } } //输出结果 a与b相等
② 使用BigDecimal
定义值,再进行运算操作,最后使用compareTo
方法比较
public class BigDecimalDemo { public static void main(String[] args) { 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.compareTo(y)==0){ System.out.println("x与y相等"); } } } //输出结果 x与y相等
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
的实际能表达的精度对尾数进行了截断。
BigDecimal good1 = new BigDecimal("0.1"); BigDecimal good2 = BigDecimal.valueOf(0.1);
①将BigDecimal(double)
==》BigDecimal(String)
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal(Double.toString(0.1)); System.out.println("a=" + a); } } //输出结果 a=0.1
②使用BigDecimal
类的valueOf
方法
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = BigDecimal.valueOf(0.1); System.out.println("a=" + a); } } //输出结果 a=0.1
BigDecimal
除法避坑我们使用带有3个参数的divide
方法来填1.4中的坑
BigDecimal.divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
方法的具体使用我们再下一小节中再详细说
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal("0.2"); BigDecimal b = new BigDecimal("0.3"); //这里就简单的看作四舍五入就行了 System.out.println("a除以b等于:"+ a.divide(b, 2, RoundingMode.HALF_UP)); } } //输出结果 a除以b等于:0.67
BigDecimal
常用方法public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal(Double.toString(0.1)); BigDecimal b = BigDecimal.valueOf(0.2); System.out.println("a + b ="+a.add(b)); } } //输出结果 a + b =0.3
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal(Double.toString(3.5)); BigDecimal b = BigDecimal.valueOf(2.1); System.out.println("a - b ="+a.subtract(b)); } } //输出结果 a - b =1.4
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal(Double.toString(2.5)); BigDecimal b = BigDecimal.valueOf(3.26); System.out.println("a * b ="+a.multiply(b)); } } //输出结果 a * b =8.150
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】 | |
CEILING |
CEILING英文是天花板的意思,可以理解为向”大“舍入【0.333-->0.34 -0.333 -->-0.33】 | |
FLOOR |
FLOOR有地板的意思,可以理解为向”小“舍入【0.333-->0.33 -0.333 -->-0.34】 | |
HALF_UP |
向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为向上舍入的舍入其实就是四舍五入【>=0.5 入,<0.5的舍去】 | |
HALF_DOWN |
向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为上舍入的舍入,其实就是五舍六入 【>0.5 的入,<=0.5 的舍去】 | |
HALF_EVEN |
向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则向相邻的偶数舍入【0.135-->0.14 0.125-->0.12】 | |
UNNECESSARY |
断言请求的操作具有精确的结果,因此不需要舍入 |
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal numA = new BigDecimal("1"); BigDecimal numB = new BigDecimal("-1"); BigDecimal numC = new BigDecimal("3"); // 保留两位小数,舍入模式为UP System.out.println("1/3保留两位小数(UP) = " + numA.divide(numC, 2, RoundingMode.UP)); System.out.println("-1/3保留两位小数(UP) = " + numB.divide(numC, 2, RoundingMode.UP)); // 保留两位小数,舍入模式为DOWN System.out.println("1/3保留两位小数(DOWN) = " + numA.divide(numC, 2, RoundingMode.DOWN)); System.out.println("-1/3保留两位小数(DOWN) = " + numB.divide(numC, 2, RoundingMode.DOWN)); // 保留两位小数,舍入模式为CEILING System.out.println("1/3保留两位小数(CEILING) = " + numA.divide(numC, 2, RoundingMode.CEILING)); System.out.println("-1/3保留两位小数(CEILING) = " + numB.divide(numC, 2, RoundingMode.CEILING)); // 保留两位小数,舍入模式为FLOOR System.out.println("1/3保留两位小数(FLOOR) = " + numA.divide(numC, 2, RoundingMode.FLOOR)); System.out.println("-1/3保留两位小数(FLOOR) = " + numB.divide(numC, 2, RoundingMode.FLOOR)); BigDecimal numD = new BigDecimal("1"); BigDecimal numE = new BigDecimal("-1"); BigDecimal numF = new BigDecimal("8"); // 保留两位小数,舍入模式为HALF_UP System.out.println("1/8(=0.125)保留两位小数(HALF_UP) = " + numD.divide(numF, 2, RoundingMode.HALF_UP)); System.out.println("-1/8(=0.125)保留两位小数(HALF_UP) = " + numE.divide(numF, 2, RoundingMode.HALF_UP)); // 保留两位小数,舍入模式为HALF_DOWN System.out.println("1/8(=0.125)保留两位小数(HALF_DOWN) = " + numD.divide(numF, 2, RoundingMode.HALF_DOWN)); System.out.println("-1/8(=0.125)保留两位小数(HALF_DOWN) = " + numE.divide(numF, 2, RoundingMode.HALF_DOWN)); // 保留两位小数,舍入模式为HALF_EVEN System.out.println("0.54/4(=0.135)保留两位小数(HALF_EVEN) = " + new BigDecimal("0.54").divide(new BigDecimal("4"), 2, RoundingMode.HALF_EVEN)); System.out.println("1/8(=0.125)保留两位小数(HALF_EVEN) = " + numE.divide(numF, 2, RoundingMode.HALF_EVEN)); //UNNECESSARY,会报异常 System.out.println("1/8(=0.125) = " + numE.divide(numF, RoundingMode.UNNECESSARY)); } } //输出结果 1/3保留两位小数(UP) = 0.34 -1/3保留两位小数(UP) = -0.34 1/3保留两位小数(DOWN) = 0.33 -1/3保留两位小数(DOWN) = -0.33 1/3保留两位小数(CEILING) = 0.34 -1/3保留两位小数(CEILING) = -0.33 1/3保留两位小数(FLOOR) = 0.33 -1/3保留两位小数(FLOOR) = -0.34 1/8(=0.125)保留两位小数(HALF_UP) = 0.13 -1/8(=0.125)保留两位小数(HALF_UP) = -0.13 1/8(=0.125)保留两位小数(HALF_DOWN) = 0.12 -1/8(=0.125)保留两位小数(HALF_DOWN) = -0.12 0.54/4(=0.135)保留两位小数(HALF_EVEN) = 0.14 1/8(=0.125)保留两位小数(HALF_EVEN) = -0.12 Exception in thread "main" java.lang.ArithmeticException: Rounding necessary
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal(Double.toString(2.3)); BigDecimal b = new BigDecimal(10200000); System.out.println("BigDecimal转字符串:"+a.toString()); System.out.println("BigDecimal转double:"+a.doubleValue()); System.out.println("BigDecimal转float:"+a.floatValue()); System.out.println("BigDecimal转长整型:"+b.longValue()); System.out.println("BigDecimal转int:"+b.intValue()); } } //输出结果 BigDecimal转字符串:2.3 BigDecimal转double:2.3 BigDecimal转float:2.3 BigDecimal转长整型:10200000 BigDecimal转int:10200000
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal(Double.toString(2.35)); BigDecimal b = BigDecimal.valueOf(-2.35); System.out.println("a的绝对值是:" + a.abs()); System.out.println("b的绝对值是:" + b.abs()); } } //输出结果 a的绝对值是:2.35 b的绝对值是:2.35
《阿里巴巴Java开发手册》第一章 1.4 OOP规约 中提到
❾【强制】 浮点数之间的等值判断,基本数据类型不能用==进行比较,包装数据类型不能用equals
方法判断。
说明: 浮点数采用“尾数+阶码”的编码方式,类似于科学计数法的“有效数字+指数“ 的表示方式。
二级制无法精确表示大部分十进制小数,具体原理参考《码出高效,Java开发手册》
反例: 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)<diff){ System.out.println("true"); } 2)使用BigDecimal定义值,再进行浮点数的运算操作。 BigDecimal a = BigDecimal("0.1"); BigDecimal b = BigDecimal("0.9"); BigDecimal c = BigDecimal("0.8"); BigDecimal x = a.subtract(b); BigDecimal y = b.subtract(c); /** *BigDecimal的等值比较应使用compareTo()方法,而不是equals() 方法。 *说明:equals()方法会比较值和精度(1.0 与1.00 返回结果为false), *而compareTo()则会忽略精度。 **/ if (x.compareTo(y)==0){ System.out.println("true"); }
等值比较用compareTo(BigDecimal val)
方法
a.compareTo(b)
public class BigDecimalDemo { public static void main(String[] args) { BigDecimal a = new BigDecimal("0.5"); BigDecimal b = new BigDecimal("0.8"); BigDecimal c = new BigDecimal("0.3"); BigDecimal d = new BigDecimal("0.5"); System.out.println("a与b比较结果:"+a.compareTo(b)); System.out.println("a与c比较结果:"+a.compareTo(c)); System.out.println("a与d比较结果:"+a.compareTo(d)); } } //输出结果 a与b比较结果:-1 a与c比较结果:1 a与d比较结果:0
BigDecimal
格式化
NumberFormat
类的format()
方法可以使用BigDecimal
对象作为参数,可以对超出16位有效数字的货币值,百分值,以及一般数值进行格式化控制
public class BigDecimalDemo { public static void main(String[] args) { NumberFormat money = 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("贷款金额:" + money.format(loanAmount)); System.out.println("利率:" + percent.format(interestRate)); System.out.println("利息:" + money.format(interest)); } } //输出结果 贷款金额:¥15,000.48 利率:0.8% 利息:¥120.00
BigDecimal
工具类为了更加方便的使用
BigDecimal
我们可以将其常用方法封装成工具类
package com.xiezhr.util; import java.math.BigDecimal; import java.math.RoundingMode; /** * 简化BigDecimal计算的小工具类 */ public class BigDecimalUtil { /** * 默认除法运算精度 */ private static final int DEF_DIV_SCALE = 10; private BigDecimalUtil() { } /** * 提供精确的加法运算。 * * @param v1 被加数 * @param v2 加数 * @return 两个参数的和 */ public static double add(double v1, double v2) { BigDecimal b1 = BigDecimal.valueOf(v1); BigDecimal b2 = BigDecimal.valueOf(v2); return b1.add(b2).doubleValue(); } /** * 提供精确的减法运算。 * * @param v1 被减数 * @param v2 减数 * @return 两个参数的差 */ public static double subtract(double v1, double v2) { BigDecimal b1 = BigDecimal.valueOf(v1); BigDecimal b2 = BigDecimal.valueOf(v2); return b1.subtract(b2).doubleValue(); } /** * 提供精确的乘法运算。 * * @param v1 被乘数 * @param v2 乘数 * @return 两个参数的积 */ public static double multiply(double v1, double v2) { BigDecimal b1 = BigDecimal.valueOf(v1); BigDecimal b2 = BigDecimal.valueOf(v2); return b1.multiply(b2).doubleValue(); } /** * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 * 小数点以后10位,以后的数字四舍五入。 * * @param v1 被除数 * @param v2 除数 * @return 两个参数的商 */ public static double divide(double v1, double v2) { return divide(v1, v2, DEF_DIV_SCALE); } /** * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 * 定精度,以后的数字四舍五入。 * * @param v1 被除数 * @param v2 除数 * @param scale 表示表示需要精确到小数点以后几位。 * @return 两个参数的商 */ public static double divide(double v1, double v2, int scale) { if (scale < 0) { throw new IllegalArgumentException( "The scale must be a positive integer or zero"); } BigDecimal b1 = BigDecimal.valueOf(v1); BigDecimal b2 = BigDecimal.valueOf(v2); return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue(); } /** * 提供精确的小数位四舍五入处理。 * * @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 = BigDecimal.valueOf(v); BigDecimal one = new BigDecimal("1"); return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue(); } /** * 提供精确的类型转换(Float) * * @param v 需要被转换的数字 * @return 返回转换结果 */ public static float convertToFloat(double v) { BigDecimal b = new BigDecimal(v); return b.floatValue(); } /** * 提供精确的类型转换(Int)不进行四舍五入 * * @param v 需要被转换的数字 * @return 返回转换结果 */ public static int convertsToInt(double v) { BigDecimal b = new BigDecimal(v); return b.intValue(); } /** * 提供精确的类型转换(Long) * * @param v 需要被转换的数字 * @return 返回转换结果 */ public static long convertsToLong(double v) { BigDecimal b = new BigDecimal(v); return b.longValue(); } /** * 返回两个数中大的一个值 * * @param v1 需要被对比的第一个数 * @param v2 需要被对比的第二个数 * @return 返回两个数中大的一个值 */ public static double returnMax(double v1, double v2) { BigDecimal b1 = new BigDecimal(v1); BigDecimal b2 = new BigDecimal(v2); return b1.max(b2).doubleValue(); } /** * 返回两个数中小的一个值 * * @param v1 需要被对比的第一个数 * @param v2 需要被对比的第二个数 * @return 返回两个数中小的一个值 */ public static double returnMin(double v1, double v2) { BigDecimal b1 = new BigDecimal(v1); BigDecimal b2 = new BigDecimal(v2); return b1.min(b2).doubleValue(); } /** * 精确对比两个数字 * * @param v1 需要被对比的第一个数 * @param v2 需要被对比的第二个数 * @return 如果两个数一样则返回0,如果第一个数比第二个数大则返回1,反之返回-1 */ public static int compareTo(double v1, double v2) { BigDecimal b1 = BigDecimal.valueOf(v1); BigDecimal b2 = BigDecimal.valueOf(v2); return b1.compareTo(b2); } }
BigDecimal
String
的构造函数BigDecimal
都是不可变的,在进行每一步运算时,都会产生一个新的对象,所以在做加减乘除运算时千万要保存操作后的值通过本期内容,你还会掉金钱陷阱里么?
本期内容到此就结束了,我们下期再见。(●'◡'●)