Java中的金錢陷阱
2023-06-07 06:01:54
前言
有多少小夥伴是被標題 騙 吸引進來的呢，我可不是標題黨，今天的文章呢確實跟」金錢「有關係。
但是我們說的不是過度追求金錢而掉入陷阱，而是要說一說在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】 
CEILINGCEILING英文是天花板的意思，可以理解為向」大「舍入【0.333-->0.34 -0.333 -->-0.33】 
FLOORFLOOR有地板的意思，可以理解為向」小「舍入【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都是不可變的，在進行每一步運算時，都會產生一個新的物件，所以在做加減乘除運算時千萬要儲存操作後的值
通過本期內容，你還會掉金錢陷阱裡麼？
本期內容到此就結束了，我們下期再見。(●'◡'●)