在使用Java，double 進行運算時，經常出現精度丟失的問題，總是在一個正確的結果左右偏0.0000**1。 特別在實際專案中，通過一個公式校驗該值是否大於0，如果大於0我們會做一件事情，小於0我們又處理其他事情。 這樣的情況通過double計算出來的結果去和0比較大小，尤其是有小數點的時候，經常會因為精度丟失而導致程式處理流程出錯。

 首先貼一個使用的程式碼：

/**
     * 將double型別資料轉為字串（如將18.4轉為1840，如果需要1840.0，把int強轉去掉即可）
     * @param d
     * @return
     */
    public static String double2String(double d){
        BigDecimal bg = new BigDecimal(d * 100);
        double doubleValue = bg.setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue();
        return  String.valueOf((int)doubleValue);
    }
 

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型別進行運算時，做好對結果進行處理，然後拿這個值去做其他事情。 

}

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

1. publicstaticvoid main(String[] args) {  
2.         System.out.println("12.5的四捨五入值：" + Math.round(12.5));  
3.         System.out.println("-12.5的四捨五入值：" + Math.round(-12.5));  
4.     }  
5. Output:  
6. 12.5的四捨五入值：13
7. -12.5的四捨五入值：-12

      四捨五入其實在金融方面運用的非常多，尤其是銀行的利息。我們都知道銀行的盈利渠道主要是利息差，它從儲戶手裡收集資金，然後放貸出去，期間產生的利息差就是銀行所獲得的利潤。如果我們採用平常四捨五入的規則話，這裡採用每10筆存款利息計算作為模型，如下：

      四舍：0.000、0.001、0.002、0.003、0.004。這些舍的都是銀行賺的錢。

      五入：0.005、0.006、0.007、0.008、0.009。這些入的都是銀行虧的錢，分別為：0.005、0.004、.003、0.002、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. publicstaticvoid 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.         System.out.println("季利息是："+i);  
6.         }  
7. Output:  
8. 季利息是：562.50

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

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

         2、 ROUND_DOWN：趨向零方向舍入。向絕對值最小的方向輸入，所有的位都要捨棄，不存在進位情況。

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

         4、 ROUND_FLOOR：向負無窮方向舍入。向負無窮方向靠攏。若是正數，舍入行為類似於ROUND_DOWN；若為負數，舍入行為類似於ROUND_UP。

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

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

         7、 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. String result = String .format(”%.2f”);  
3. %.2f %. 表示 小數點前任意位數   2 表示兩位小數 格式後的結果為f 表示浮點型。  

      此外如果使用struts標籤做輸出的話，有個format屬性,設定為format="0.00"就是保留兩位小數

      例如：

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

4：對於一般add、subtract、multiply方法的小數位格式化如下：