前言
有多少小伙伴是被标题 骗 吸引进来的呢,我可不是标题党,今天的文章呢确实跟”金钱“有联系。
可是咱们说的不是过度追求金钱而掉入圈套,而是要说一说在Java程序中,各种跟金钱运算有关的圈套。
日常工作中咱们经常会涉及到各种金额这样浮点数的运算。
一旦涉及到金额的运算就必须慎之又慎,一旦有精度丢掉,或者其他运算错误就或许形成无可挽回的丢失。
一 、 存在的圈套
这一末节咱们先将圈套列出来,下一末节分别给出解决计划。
咱们先来看看到底有哪些坑等着咱们去踩
1.1 浮点运算精度丢掉圈套
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
1.2 浮点数等值判别圈套
① 根本类型与包装类型判别浮点数是否持平
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
1.3 BigDecimal
结构办法中的圈套
public class BigDecimalDemo {
public static void main(String[] args) {
BigDecimal a = new BigDecimal(0.1f);
System.out.println("a= "+ a);
}
}
//输出成果
a= 0.100000001490116119384765625
1.4 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)
二、避免圈套
2.1 浮点数运算避坑
① 咱们先来看看为什么浮点数(也便是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
2.2 浮点数等值判别避坑
日常开发中肯守时免不了比较两个浮点数大小的,这儿呢就把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持平
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
的实际能表达的精度对尾数进行了切断。
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
2.4 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
常用办法
- 常用结构办法
- 常用办法
3.1 加法运算 add
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
3.2 减法运算 subtract
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
3.3 乘法运算 multiply
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
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】 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
3.5 值转化
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
3.6 绝对值 abs
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
3.7 等值比较
《阿里巴巴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)
- -1:表明a小于b
- 0:表明a等于b
- 1:表明a大于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
都是不可变的,在进行每一步运算时,都会发生一个新的目标,所以在做加减乘除运算时千万要保存操作后的值
经过本期内容,你还会掉金钱圈套里么?
本期内容到此就结束了,咱们下期再见。(●’◡’●)