關於Java中用Double型運算時精度丟失的問題

時間 2019-12-14

標籤關於 java 中用 double 運算精度丟失問題欄目 Java 简体版

原文原文鏈接

注：轉自 https://blog.csdn.net/bleach_kids/article/details/49129943java

在使用Java，double 進行運算時，常常出現精度丟失的問題，老是在一個正確的結果左右偏0.0000**1。特別在實際項目中，經過一個公式校驗該值是否大於0，若是大於0咱們會作一件事情，小於0咱們又處理其餘事情。這樣的狀況經過double計算出來的結果去和0比較大小，尤爲是有小數點的時候，常常會由於精度丟失而致使程序處理流程出錯。git

BigDecimal
在《Effective Java》這本書中也提到這個原則，float和double只能用來作科學計算或者是工程計算，在商業計算中咱們要用 java.math.BigDecimal。BigDecimal一共有4個夠造方法，咱們不關心用BigInteger來夠造的那兩個，那麼還有兩個，它們是：
BigDecimal(double val)
Translates a double into a BigDecimal.
BigDecimal(String val)
Translates the String repre sentation of a BigDecimal into a BigDecimal.
上面的API簡要描述至關的明確，並且一般狀況下，上面的那一個使用起來要方便一些。咱們可能想都不想就用上了，會有什麼問題呢？等到出了問題的時候，才發現上面哪一個夠造方法的詳細說明中有這麼一段：
Note: the results of this constructor can be somewhat unpredictable. One might assume that new BigDecimal(.1) is exactly equal to .1, but it is actually equal to .1000000000000000055511151231257827021181583404541015625. This is so because .1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the long value that is being passed in to the constructor is not exactly equal to .1, appearances nonwithstanding.
The (String) constructor, on the other hand, is perfectly predictable: new BigDecimal(".1") is exactly equal to .1, as one would expect. Therefore, it is generally recommended that the (String) constructor be used in preference to this one.
原來咱們若是須要精確計算，非要用String來夠造BigDecimal不可！在《Effective Java》一書中的例子是用String來夠造BigDecimal的，可是書上卻沒有強調這一點，這也許是一個小小的失誤吧。

解決方案
如今咱們已經能夠解決這個問題了，原則是使用BigDecimal而且必定要用String來夠造。
可是想像一下吧，若是咱們要作一個加法運算，須要先將兩個浮點數轉爲String，而後夠形成BigDecimal，在其中一個上調用add方法，傳入另一個做爲參數，而後把運算的結果（BigDecimal）再轉換爲浮點數。你可以忍受這麼煩瑣的過程嗎？下面咱們提供一個工具類Arith來簡化操做。它提供如下靜態方法，包括加減乘除和四捨五入：
public static double add(double v1,double v2)
public static double sub(double v1,double v2)
public static double mul(double v1,double v2)
public static double div(double v1,double v2)
public static double div(double v1,double v2,int scale)
public static double round(double v,int scale)算法

因此通常對double類型進行運算時，作好對結果進行處理，而後拿這個值去作其餘事情。 app

使用以下：ide

 1  /**   
 2      * 對double數據進行取精度.   
 3      * @param value  double數據.   
 4      * @param scale  精度位數(保留的小數位數).   
 5      * @param roundingMode  精度取值方式.   
 6      * @return 精度計算後的數據.   
 7      */   
 8     public static double round(double value, int scale,  
 9              int roundingMode) {    
10         BigDecimal bd = new BigDecimal(value);    
11         bd = bd.setScale(scale, roundingMode);    
12         double d = bd.doubleValue();    
13         bd = null;    
14         return d;    
15     }    
16 
17 
18      /** 
19      * double 相加 
20      * @param d1 
21      * @param d2 
22      * @return 
23      */ 
24     public double sum(double d1,double d2){ 
25         BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
26         BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
27         return bd1.add(bd2).doubleValue(); 
28     } 
29 
30 
31     /** 
32      * double 相減 
33      * @param d1 
34      * @param d2 
35      * @return 
36      */ 
37     public double sub(double d1,double d2){ 
38         BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
39         BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
40         return bd1.subtract(bd2).doubleValue(); 
41     } 
42 
43     /** 
44      * double 乘法 
45      * @param d1 
46      * @param d2 
47      * @return 
48      */ 
49     public double mul(double d1,double d2){ 
50         BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
51         BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
52         return bd1.multiply(bd2).doubleValue(); 
53     } 
54 
55 
56     /** 
57      * double 除法 
58      * @param d1 
59      * @param d2 
60      * @param scale 四捨五入 小數點位數 
61      * @return 
62      */ 
63     public double div(double d1,double d2,int scale){ 
64         //  固然在此以前，你要判斷分母是否爲0，    
65         //  爲0你能夠根據實際需求作相應的處理 
66 
67         BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
68         BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
69         return bd1.divide  
70                (bd2,scale,BigDecimal.ROUND_HALF_UP).doubleValue(); 
71     }

這樣，計算double類型的數據計算問題就能夠處理了。
另外補充一下 JavaScript 四捨五入的方法：
小數點問題工具

1 Math.round(totalAmount*100)/100 (保留 2 位) 
2 
3 function formatFloat(src, pos) 
4 { 
5   return Math.round(src*Math.pow(10, pos))/Math.pow(10, pos); 
6 }

四捨五入是咱們小學的數學問題，這個問題對於咱們程序猿來講就相似於1到10的加減乘除那麼簡單了。在講解之間咱們先看以下一個經典的案例：this

1 public static void main(String[] args) {  
2         System.out.println("12.5的四捨五入值：" + Math.round(12.5));  
3         System.out.println("-12.5的四捨五入值：" + Math.round(-12.5));  
4     }

Output:
12.5的四捨五入值：13
-12.5的四捨五入值：-12 spa

這是四捨五入的經典案例，也是咱們參加校招時候常常會遇到的(貌似我參加筆試的時候遇到過好屢次)。從這兒結果中咱們發現這兩個絕對值相同的數字，爲什麼近似值會不一樣呢？其實這與Math.round採用的四捨五入規則來決定。.net

四捨五入其實在金融方面運用的很是多，尤爲是銀行的利息。咱們都知道銀行的盈利渠道主要是利息差，它從儲戶手裏收集資金，而後放貸出去，期間產生的利息差就是銀行所得到的利潤。若是咱們採用日常四捨五入的規則話，這裏採用每10筆存款利息計算做爲模型，以下：code

四舍：0.000、0.00一、0.00二、0.00三、0.004。這些舍的都是銀行賺的錢。

五入：0.00五、0.00六、0.00七、0.00八、0.009。這些入的都是銀行虧的錢，分別爲：0.00五、0.00四、.00三、0.00二、0.001。

因此對於銀行來講它的盈利應該是0.000 + 0.001 + 0.002 + 0.003 + 0.004 - 0.005 - 0.004 - 0.003 - 0.002 - 0.001 = -0.005。從結果中能夠看出每10筆的利息銀行可能就會損失0.005元，千萬別小看這個數字，這對於銀行來講就是一筆很是大的損失。面對這個問題就產生了以下的銀行家涉入法了。該算法是由美國銀行家提出了，主要用於修正採用上面四捨五入規則而產生的偏差。以下：

捨去位的數值小於5時，直接捨去。

捨去位的數值大於5時，進位後捨去。

當捨去位的數值等於5時，若5後面還有其餘非0數值，則進位後捨去，若5後面是0時，則根據5前一位數的奇偶性來判斷，奇數進位，偶數捨去。

對於上面的規則咱們舉例說明

11.556 = 11.56 ------六入

11.554 = 11.55 -----四舍

11.5551 = 11.56 -----五後有數進位

11.545 = 11.54 -----五後無數，若前位爲偶數應捨去

11.555 = 11.56 -----五後無數，若前位爲奇數應進位

下面實例是使用銀行家舍入法：

1 public static void main(String[] args) {  
2         BigDecimal d = new BigDecimal(100000);      //存款  
3         BigDecimal r = new BigDecimal(0.001875*3);   //利息  
4         BigDecimal i = d.multiply(r).setScale(2,RoundingMode.HALF_EVEN);     //使用銀行家算法   
5           
6         System.out.println("季利息是："+i);  
7         }

Output:

季利息是：562.50

在上面簡單地介紹了銀行家舍入法，目前java支持7中舍入法：

一、 ROUND_UP：遠離零方向舍入。向絕對值最大的方向舍入，只要捨棄位非0即進位。

二、 ROUND_DOWN：趨向零方向舍入。向絕對值最小的方向輸入，全部的位都要捨棄，不存在進位狀況。

三、 ROUND_CEILING：向正無窮方向舍入。向正最大方向靠攏。如果正數，舍入行爲相似於ROUND_UP，若爲負數，舍入行爲相似於ROUND_DOWN。Math.round()方法就是使用的此模式。

四、 ROUND_FLOOR：向負無窮方向舍入。向負無窮方向靠攏。如果正數，舍入行爲相似於ROUND_DOWN；若爲負數，舍入行爲相似於ROUND_UP。

五、 HALF_UP：最近數字舍入(5進)。這是咱們最經典的四捨五入。

六、 HALF_DOWN：最近數字舍入(5舍)。在這裏5是要捨棄的。

七、 HAIL_EVEN：銀行家舍入法。

提到四捨五入那麼保留位就必不可少了，在java運算中咱們可使用多種方式來實現保留位。

保留位

方法一：四捨五入

1 double   f   =   111231.5585;  
2 BigDecimal   b   =   new   BigDecimal(f);  
3 double   f1   =   b.setScale(2,   RoundingMode.HALF_UP).doubleValue();

在這裏使用BigDecimal ，而且採用setScale方法來設置精確度，同時使用RoundingMode.HALF_UP表示使用最近數字舍入法則來近似計算。在這裏咱們能夠看出BigDecimal和四捨五入是絕妙的搭配。

方式二：

1 java.text.DecimalFormat   df   =new   java.text.DecimalFormat(」#.00″);  
2 df.format(你要格式化的數字);

例：new java.text.DecimalFormat(」#.00″).format(3.1415926)

#.00 表示兩位小數 #.0000四位小數以此類推…

方式三：

1 double d = 3.1415926;  
2   
3 String result = String .format(」%.2f」);

%.2f %. 表示小數點前任意位數 2 表示兩位小數格式後的結果爲f 表示浮點型。

方式四：

此外若是使用struts標籤作輸出的話，有個format屬性,設置爲format="0.00"就是保留兩位小數

例如：

1 <bean:write name="entity" property="dkhAFSumPl"  format="0.00" />  
2   
3 或者  
4   
5 <fmt:formatNumber type="number" value="${10000.22/100}" maxFractionDigits="0"/>  
6   
7 maxFractionDigits表示保留的位數

BigDecimal.setScale 處理java小數點

BigDecimal.setScale()方法用於格式化小數點
setScale(1)表示保留一位小數，默認用四捨五入方式
setScale(1,BigDecimal.ROUND_DOWN)直接刪除多餘的小數位，如2.35會變成2.3
setScale(1,BigDecimal.ROUND_UP)進位處理，2.35變成2.4
setScale(1,BigDecimal.ROUND_HALF_UP)四捨五入，2.35變成2.4

setScaler(1,BigDecimal.ROUND_HALF_DOWN)四捨五入，2.35變成2.3，若是是5則向下舍

註釋：

1：

scale指的是你小數點後的位數。好比123.456則score就是3.
score()就是BigDecimal類中的方法啊。
好比:BigDecimal b = new BigDecimal("123.456");

b.scale(),返回的就是3.

2：
roundingMode是小數的保留模式。它們都是BigDecimal中的常量字段,有不少種。
好比：BigDecimal.ROUND_HALF_UP表示的就是4舍5入。
3：
pubilc BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
的意思是說：我用一個BigDecimal對象除以divisor後的結果，而且要求這個結果保留有scale個小數位，roundingMode表示的就是保留模式是什麼，是四捨五入啊仍是其它的，你能夠本身選！

4：對於通常add、subtract、multiply方法的小數位格式化以下：

BigDecimal mData = new BigDecimal("9.655").setScale(2, BigDecimal.ROUND_HALF_UP);
System.out.println("mData=" + mData);

----結果：----- mData=9.66