java中BigDecimal的使用踩坑記錄
一、踩坑記錄
踩坑一：創(chuàng)建 BigDecimal精度丟失的坑
在BigDecimal 中提供了多種創(chuàng)建方式，可以通過new 直接創(chuàng)建，也可以通過 BigDecimal#valueOf 創(chuàng)建。這兩種方式使用不當，也會導致精度問題。如下：
public static void main(String[] args) throws Exception {
BigDecimal b1= new BigDecimal(0.1);
System.out.println(b1);
BigDecimal b2= BigDecimal.valueOf(0.1);
System.out.println(b2);
BigDecimal b3= BigDecimal.valueOf(0.111111111111111111111111111234);
System.out.println(b3);
}執(zhí)行結果：
0.1000000000000000055511151231257827021181583404541015625
0.1
0.1111111111111111
上面示例中兩個方法都傳入了double類型的參數0.1但是 b1 還是出現了精度的問題。造成這種問題的原因是 0.1 這個數字計算機是無法精確表示的，送給 BigDecimal 的時候就已經丟精度了，而 BigDecimal#valueOf 的實現卻完全不同。如下源碼所示，BigDecimal#valueOf 中是把浮點數轉換成了字符串來構造的BigDecimal，因此避免了問題。
public static BigDecimal valueOf(double val) {
return new BigDecimal(Double.toString(val));
}結論：
第一，在使用BigDecimal構造函數時，盡量傳遞字符串而非浮點類型；
第二，如果無法滿足第一條，則可采用BigDecimal#valueOf方法來構造初始化值。但是valueOf受double類型精度影響，當傳入參數小數點后的位數超過double允許的16位精度還是可能會出現問題的
踩坑二：等值比較的坑
一般在比較兩個值是否相等時，都是用equals 方法，但是，在BigDecimal 中使用equals可能會導致結果錯誤，BigDecimal 中提供了 compareTo 方法，在很多時候需要使用compareTo 比較兩個值。如下所示：
public static void main(String[] args){
BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("1.00");
System.out.println(b1.equals(b2));
System.out.println(b1.compareTo(b2));
}執(zhí)行結果：
false
0
出現此種結果的原因是，equals不僅比較了值是否相等，還比較了精度是否相同。示例中，由于兩個值的精度不同，所有結果也就不相同。而 compareTo 是只比較值的大小。返回的值為-1（小于），0（等于），1（大于）。
結論
- 如果比較兩個BigDecimal值的大小，采用其實現的compareTo方法；
- 如果嚴格限制精度的比較，那么則可考慮使用equals方法。
踩坑三：無限精度的坑
BigDecimal 并不代表無限精度，當在兩個數除不盡的時候，就會出現無限精度的坑，如下所示：
public static void main(String[] args){
BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("3.0");
b1.divide(b2);
}執(zhí)行結果：
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.demo.controller.Test.main(Test.java:29)
在官方文檔中對該異常有如下說明：
If the quotient has a nonterminating decimal expansion and the
operation is specified to return an exact result, an
ArithmeticException is thrown. Otherwise, the exact result of the
division is returned, as done for other operations.
大致意思就是，如果在除法（divide）運算過程中，如果商是一個無限小數（如 0.333…），而操作的結果預期是一個精確的數字，那么將會拋出ArithmeticException異常。
此種情況，只需要在使用 divide方法時指定結果的精度即可：
public static void main(String[] args){
BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("3.0");
System.out.println(b1.divide(b2,2, RoundingMode.HALF_UP));//0.33
}結論：
在使用BigDecimal進行（所有）運算時，盡量指定精度和舍入模式。
踩坑四：BigDecimal三種字符串輸出的坑
在BigDecimal 轉換成字符串時，有可能輸出非你預期的結果。如下所示：
public static void main(String[] args){
BigDecimal bg = new BigDecimal("1E11");
System.out.println(bg.toString()); // 1E+11
System.out.println(bg.toPlainString()); // 100000000000
System.out.println(bg.toEngineeringString()); // 100E+9
}執(zhí)行結果：
1E+11
100000000000
100E+9
可以看到三種方式輸出的結果可能都不相同，可能這個并不是預期的結果 ，BigDecimal 有三個方法可以轉為相應的字符串類型，切記不要用錯：
以下內容介紹java.math.BigDecimal下的三個toString方法的區(qū)別及用法
- toPlainString() : 不使用任何指數。
- toString() ：有必要時使用科學計數法。
- toEngineeringString()：有必要時使用工程計數法。 工程記數法是一種工程計算中經常使用的記錄數字的方法，與科學技術法類似，但要求10的冪必須是3的倍數
踩坑五：使用BigDecimal進行計算時參數不能為NULL
在使用BigDecimal類型進行計算時，進行加、減、乘、除、比較大小時，一定要保證參與計算的兩個值不能為空，否則會拋出java.lang.NullPointerException異常。
代碼示例：
BigDecimal b1 = new BigDecimal("1");
BigDecimal b2 = null;
System.out.println("相加："+b2.add(b1));結果：
Exception in thread "main" java.lang.NullPointerException
at com.demo.controller.Test.main(Test.java:14)
踩坑六：使用BigDecimal進行除法計算時被除數不能為0
代碼示例：
BigDecimal b1 = new BigDecimal("1");
BigDecimal b2 = new BigDecimal("0");
System.out.println(b1.divide(b2));執(zhí)行結果：
Exception in thread "main" java.lang.ArithmeticException: Division by zero
踩坑七：執(zhí)行順序不能調換（乘法交換律失效）
乘法滿足交換律是一個常識，但是在計算機的世界里，會出現不滿足乘法交換律的情況；
代碼示例：
BigDecimal b1 = BigDecimal.valueOf(1.0); BigDecimal b2 = BigDecimal.valueOf(3.0); BigDecimal b3 = BigDecimal.valueOf(3.0); System.out.println(b1.divide(b2, 2, RoundingMode.HALF_UP).multiply(b3)); // 0.990 System.out.println(b1.multiply(b3).divide(b2, 2, RoundingMode.HALF_UP)); // 1.00
執(zhí)行結果：
0.990
1.00
執(zhí)行順序交換后，產生的結果可能不同，會導致一定的問題，使用順序建議先乘后除。
二、BigDecimal概述
Java在java.math包中提供的API類BigDecimal，用來對超過16位有效位的數進行精確的運算。雙精度浮點型變量double可以處理16位有效數，但在實際應用中，可能需要對更大或者更小的數進行運算和處理。
一般情況下，對于那些不需要準確計算精度的數字，我們可以直接使用Float和Double處理，但是Double.valueOf(String) 和Float.valueOf(String)會丟失精度。所以開發(fā)中，如果我們需要精確計算的結果，則必須使用BigDecimal類來操作。
BigDecimal所創(chuàng)建的是對象，故我們不能使用傳統(tǒng)的+、-、*、/等算術運算符直接對其對象進行數學運算，而必須調用其相對應的方法。方法中的參數也必須是BigDecimal的對象。構造器是類的特殊方法，專門用來創(chuàng)建對象，特別是帶有參數的對象。
三、BigDecimal常用構造函數
3.1、常用構造函數
BigDecimal(int)
創(chuàng)建一個具有參數所指定整數值的對象
BigDecimal(double)
創(chuàng)建一個具有參數所指定雙精度值的對象
BigDecimal(long)
創(chuàng)建一個具有參數所指定長整數值的對象
BigDecimal(String)
創(chuàng)建一個具有參數所指定以字符串表示的數值的對象
3.2、使用問題分析
使用示例：
BigDecimal a =new BigDecimal(0.1);
System.out.println("a values is:"+a);
System.out.println("=====================");
BigDecimal b =new BigDecimal("0.1");
System.out.println("b values is:"+b);結果示例：
a values is:0.1000000000000000055511151231257827021181583404541015625
=====================
b values is:0.1
原因分析：
1）參數類型為double的構造方法的結果有一定的不可預知性。有人可能認為在Java中寫入newBigDecimal(0.1)所創(chuàng)建的BigDecimal正好等于 0.1（非標度值 1，其標度為 1），但是它實際上等于0.1000000000000000055511151231257827021181583404541015625。這是因為0.1無法準確地表示為 double（或者說對于該情況，不能表示為任何有限長度的二進制小數）。這樣，傳入到構造方法的值不會正好等于 0.1（雖然表面上等于該值）。
2）String 構造方法是完全可預知的：寫入 newBigDecimal(“0.1”) 將創(chuàng)建一個 BigDecimal，它正好等于預期的 0.1。因此，比較而言， 通常建議優(yōu)先使用String構造方法。
3）當double必須用作BigDecimal的源時，請注意，此構造方法提供了一個準確轉換；它不提供與以下操作相同的結果：先使用Double.toString(double)方法，然后使用BigDecimal(String)構造方法，將double轉換為String。要獲取該結果，請使用static valueOf(double)方法。
四、BigDecimal常用方法詳解
4.1、常用方法
1.add(BigDecimal)
BigDecimal對象中的值相加，返回BigDecimal對象
2.subtract(BigDecimal)
BigDecimal對象中的值相減，返回BigDecimal對象
3.multiply(BigDecimal)
BigDecimal對象中的值相乘，返回BigDecimal對象
4.divide(BigDecimal)
BigDecimal對象中的值相除，返回BigDecimal對象
5.toString()
將BigDecimal對象中的值轉換成字符串
6.doubleValue()
將BigDecimal對象中的值轉換成雙精度數
7.floatValue()
將BigDecimal對象中的值轉換成單精度數
8.longValue()
將BigDecimal對象中的值轉換成長整數
9.intValue()
將BigDecimal對象中的值轉換成整數
4.2、BigDecimal大小比較
java中對BigDecimal比較大小一般用的是bigdemical的compareTo方法
int a = bigdemical.compareTo(bigdemical2)
返回結果分析：
a = -1,表示bigdemical小于bigdemical2；
a = 0,表示bigdemical等于bigdemical2；
a = 1,表示bigdemical大于bigdemical2；
舉例：a大于等于b
new bigdemica(a).compareTo(new bigdemical(b)) >= 0
五、BigDecimal格式化
由于NumberFormat類的format()方法可以使用BigDecimal對象作為其參數，可以利用BigDecimal對超出16位有效數字的貨幣值，百分值，以及一般數值進行格式化控制。
以利用BigDecimal對貨幣和百分比格式化為例。首先，創(chuàng)建BigDecimal對象，進行BigDecimal的算術運算后，分別建立對貨幣和百分比格式化的引用，最后利用BigDecimal對象作為format()方法的參數，輸出其格式化的貨幣值和百分比。
NumberFormat currency = 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("貸款金額:\t" + currency.format(loanAmount));
System.out.println("利率:\t" + percent.format(interestRate));
System.out.println("利息:\t" + currency.format(interest));結果：
貸款金額: ￥15,000.48 利率: 0.8% 利息: ￥120.00
BigDecimal格式化保留2為小數，不足則補0：
public class NumberFormat {
public static void main(String[] s){
System.out.println(formatToNumber(new BigDecimal("3.435")));
System.out.println(formatToNumber(new BigDecimal(0)));
System.out.println(formatToNumber(new BigDecimal("0.00")));
System.out.println(formatToNumber(new BigDecimal("0.001")));
System.out.println(formatToNumber(new BigDecimal("0.006")));
System.out.println(formatToNumber(new BigDecimal("0.206")));
}
/**
* @desc 1.0~1之間的BigDecimal小數，格式化后失去前面的0,則前面直接加上0。
* 2.傳入的參數等于0，則直接返回字符串"0.00"
* 3.大于1的小數，直接格式化返回字符串
* @param obj傳入的小數
* @return
*/
public static String formatToNumber(BigDecimal obj) {
DecimalFormat df = new DecimalFormat("#.00");
if(obj.compareTo(BigDecimal.ZERO)==0) {
return "0.00";
}else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){
return "0"+df.format(obj).toString();
}else {
return df.format(obj).toString();
}
}
}結果為：
3.44
0.00
0.00
0.00
0.01
0.21
六、BigDecimal常見異常
除法的時候出現異常
原因分析：
通過BigDecimal的divide方法進行除法時當不整除，出現無限循環(huán)小數時，就會拋異常：java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
解決方法：
divide方法設置精確的小數點，如：divide(xxxxx,2)
七、BigDecimal總結
7.1、總結
在需要精確的小數計算時再使用BigDecimal，BigDecimal的性能比double和float差，在處理龐大，復雜的運算時尤為明顯。故一般精度的計算沒必要使用BigDecimal。
盡量使用參數類型為String的構造函數。
BigDecimal都是不可變的（immutable）的， 在進行每一次四則運算時，都會產生一個新的對象，所以在做加減乘除運算時要記得要保存操作后的值。
7.2、工具類推薦
package com.vivo.ars.util;
import java.math.BigDecimal;
/**
* 用于高精確處理常用的數學運算
*/
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();
}
/**
* 提供（相對）精確的除法運算，當發(fā)生除不盡的情況時，精確到
* 小數點以后10位，以后的數字四舍五入
*
* @param v1 被除數
* @param v2 除數
* @return 兩個參數的商
*/
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相對）精確的除法運算。當發(fā)生除不盡的情況時，由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();
}
/**
* 提供（相對）精確的除法運算。當發(fā)生除不盡的情況時，由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;
}
}以上就是java中BigDecimal的使用踩坑記錄的詳細內容，更多關于java BigDecimal的資料請關注腳本之家其它相關文章！
相關文章
這篇文章主要介紹了java對double數組排序示例，代碼簡單，下面我們直接上代碼,需要的朋友可以參考下2014-03-03
這篇文章主要介紹了Java封裝數組實現包含、搜索和刪除元素操作,結合實例形式分析了java針對數組元素的查找、刪除、判斷等相關操作封裝與使用技巧,需要的朋友可以參考下2020-03-03
Java GUI進階之流式布局管理器FlowLayout專項精講
FlowLayout-流式布局管理器，按水平方向依次排列放置組件，排滿一行，換下一行繼續(xù)排列。排列方向（左到右 或 右到左）取決于容器的componentOrientation屬性2022-04-04
使用Java創(chuàng)建數據透視表并導出為PDF的方法
數據透視分析是一種強大的工具，可以幫助我們從大量數據中提取有用信息并進行深入分析，本文將介紹如何使用Java來構建PivotTable以及實現數據透視分析，并將其導出為PDF2023-10-10
這篇文章主要介紹了Mybatis中的延遲加載詳細解讀,Mybatis中延遲加載又稱為懶加載,是指在進行關聯(lián)查詢時,按照設置延遲規(guī)則推遲對關聯(lián)對象的select查詢,延遲加載可以有效的減少數據庫的壓力,需要的朋友可以參考下2023-10-10
本章具體介紹了抽象類和接口，整篇文章用目前流行的手機來舉例，圖解穿插代碼案例。?JAVA成仙路從基礎開始講，后續(xù)會講到JAVA高級，中間會穿插面試題和項目實戰(zhàn)，希望能給大家?guī)韼椭?/div> 2022-03-03
這篇文章主要介紹了java過濾器中Filter,發(fā)送請求時，如果有不符合的信息將會被filter進行攔截，如果符合則會進行放行。如果感興趣可以來學習一下2021-08-08
這篇文章主要介紹了Java泛型extends及super區(qū)別實例解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-08-08
spring boot mybatis多數據源解決方案過程解析
這篇文章主要介紹了spring boot mybatis多數據源解決方案過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-11-11
這篇文章主要給大家介紹了關于Spring boot攔截器實現IP黑名單的完整步驟，文中通過示例代碼介紹的非常詳細，對大家學習或者使用Spring boot攔截器具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧2020-06-06最新評論