本文綜合網上牛人以及Java API所寫，還有自己的一些專案經歷。主要實用工具Eclipse3.5、jdk1.6，測試框架JUnit4等。

float和double只能用來做科學計算或者是工程計算，在商業計算中我們要用java.math.BigDecimal。

                                                                                                                                       -----《Effective Java》

看一個小例子：

/** * 浮點數簡單計算 * * @author mark */ public void calculate() { System.out.println(0.06 + 0.01); System.out.println(0.3 - 0.4); System.out.println(6.0155 * 100); System.out.println(156.3 / 100); } /** * 測試程式碼 * * @author mark */ @Test public void testCalculate() { orr.calculate(); }

測試結果：

0.06999999999999999 -0.10000000000000003 601.5500000000001 1.5630000000000002 

讓人不可思議，怎麼會與自己的想象差的那麼遠！但，現實確實如此！

Java中的簡單浮點數型別float和double不能夠進行運算。不光是Java，在其它很多程式語言中也有這樣的問題。在大多數情況下，計算的結果是準確的，但是多試幾次（可以做一個迴圈）就可以試出類似上面的錯誤。

再者，Math類、DecimalFormat類有對應的處理資料的方法。例項程式碼：

System.out.println(Math.round(4.015*100)/100.0); System.out.println(Math.round(4.016*100)/100.0); System.out.println(new DecimalFormat("0.00").format(4.025));

顯示結果：

4.01 4.02 4.02 

哎，還是讓人很失望。

難道在工程中，我們就這樣計算嗎？當然不是，Java還沒有“挫”，呵呵！下面談談BigDecimal。

BigDecimal有很多構造方法，詳看api文件。這裡主要說說下面兩個構造方法：

BigDecimal(double val) Translates a double into a BigDecimal which is the exact decimal representation of the double's binary floating-point value. BigDecimal(String val) Translates the string representation of a BigDecimal into a BigDecimal.

關於其他的構造方法，這裡不贅述，舉一反三吧！

這兩個構造方法，建議採用第二個，具體原因在api上解釋的很清楚。

BigDecimal public BigDecimal(double val) Translates a double into a BigDecimal which is the exact decimal representation of the double's binary floating-point value. The scale of the returned BigDecimal is the smallest value such that (10scale × val) is an integer. Notes: The results of this constructor can be somewhat unpredictable. One might assume that writing new BigDecimal(0.1) in Java creates a BigDecimal which is exactly equal to 0.1 (an unscaled value of 1, with a scale of 1), but it is actually equal to 0.1000000000000000055511151231257827021181583404541015625. This is because 0.1 cannot be represented exactly as a double (or, for that matter, as a binary fraction of any finite length). Thus, the value that is being passed in to the constructor is not exactly equal to 0.1, appearances notwithstanding. The String constructor, on the other hand, is perfectly predictable: writing new BigDecimal("0.1") creates a BigDecimal which is exactly equal to 0.1, as one would expect. Therefore, it is generally recommended that the String constructor be used in preference to this one. When a double must be used as a source for a BigDecimal, note that this constructor provides an exact conversion; it does not give the same result as converting the double to a String using the Double.toString(double) method and then using the BigDecimal(String) constructor. To get that result, use the static valueOf(double) method. Parameters: val - double value to be converted to BigDecimal. Throws: NumberFormatException - if val is infinite or NaN.  

翻譯一下：

BigDecimal public BigDecimal(double val) 將 double 轉換為 BigDecimal，後者是 double 的二進位制浮點值準確的十進位制表示形式。返回的 BigDecimal 的標度是使 (10scale × val) 為整數的最小值。 注： 此構造方法的結果有一定的不可預知性。有人可能認為在 Java 中寫入 new BigDecimal(0.1) 所建立的 BigDecimal 正好等於 0.1（非標度值 1，其標度為 1），但是它實際上等於 0.1000000000000000055511151231257827021181583404541015625。這是因為 0.1 無法準確地表示為 double（或者說對於該情況，不能表示為任何有限長度的二進位制小數）。這樣，傳入 到構造方法的值不會正好等於 0.1（雖然表面上等於該值）。 另一方面，String 構造方法是完全可預知的：寫入 new BigDecimal("0.1") 將建立一個 BigDecimal，它正好 等於預期的 0.1。因此，比較而言，通常建議優先使用 String 構造方法。 當 double 必須用作 BigDecimal 的源時，請注意，此構造方法提供了一個準確轉換；它不提供與以下操作相同的結果：先使用 Double.toString(double) 方法，然後使用 BigDecimal(String) 構造方法，將 double 轉換為 String。要獲取該結果，請使用 static valueOf(double) 方法。 引數： val - 要轉換為 BigDecimal 的 double 值。 丟擲： NumberFormatException - 如果 val 為無窮大或 NaN。 

使用BigDecimal，可以獲得交準確的計算結果，並且可以自己定義小數精度，具有一定的靈活性。例項程式碼：

/** * 對浮點數進行準確的除法計算 * * @param number * 被除數（被除數÷除數=商） * @return 商值 */ public double overFormat(double number) { // 被除數 BigDecimal dividend = new BigDecimal(Double.toString(number)); // 除數 BigDecimal divider = new BigDecimal(Double.toString(1)); // ROUND_UP引數表示只要小數點後面第一位不是0,都會被自動進位如192.1-->193.0 return dividend.divide(divider, 0, BigDecimal.ROUND_UP).doubleValue(); } 

其中，BigDecimal有很多常量欄位。ROUND_HALF_UP表示四捨五入。例項程式碼：

/** * 對浮點數進行準確除法的計算 * * @param precision * 精度值，保留小數點後幾位 * @param number * 被除數（被除數÷除數=商） * @return 商值 */ public double format(int precision, double number) { BigDecimal dividend = new BigDecimal(Double.toString(number)); BigDecimal divider = new BigDecimal(Double.toString(4)); // b1除以b2,如果商是迴圈小數（除不盡）保留小數點位數為precision，BigDecimal.ROUND_HALF_UP表示四捨五入 // 例如在197/7=28.142857143，經過該方法(precision=3)處理為28.143 // 如果可以除盡，並且precision值大於實際小數點後位數則保留實際位數。若precision小於實際小數點後位數則先四捨五入保留precision位 return dividend.divide(divider, precision, BigDecimal.ROUND_HALF_UP) .doubleValue(); } 

在JUnit4的幫助下，很好地完成了許多測試，解開了很多疑惑。如果你不明白最好還是多加測試。也許，你有更多的發現。

在好奇心的驅使下，又看看BigDecimal原始碼，主要涉及到其valueOf(double val)方法，該方法是靜態方法，原始碼如下：

public static BigDecimal valueOf(double val) { // Reminder: a zero double returns '0.0', so we cannot fastpath // to use the constant ZERO. This might be important enough to // justify a factory approach, a cache, or a few private // constants, later. return new BigDecimal(Double.toString(val)); }  

可以看出，valueOf(double val)方法以BigDecimal(Double.toString(val))方式返回一個BigDecimal物件。所以在以double為源的時候創

建BigDecimal物件，可以採用該方法。修改上面例項程式碼如下：

/** * 對浮點數進行準確的除法計算 * * @param number * 被除數（被除數÷除數=商） * @return 商值 */ public double overFormat(double number) { // 被除數 BigDecimal dividend = BigDecimal.valueOf(number);//new BigDecimal(Double.toString(number)); // 除數 BigDecimal divider = BigDecimal.valueOf(1.0);//new BigDecimal(Double.toString(1)); // ROUND_UP引數表示只要小數點後面第一位不是0,都會被自動進位如192.1-->193.0 return dividend.divide(divider, 0, BigDecimal.ROUND_UP).doubleValue(); } 

在看原始碼的時候，經常看到別人使用valueof**方法，難道它有什麼與眾不同嗎？研究一下ing.....

首先，研究一下Integer的建立方式：

public static void main(String[] args) { //自動裝箱 Integer a = 100; Integer b = 100; System.out.println("equals--" + a.equals(b));//true System.out.println(a == b);//true //new Integer c = new Integer(100); Integer d = new Integer(100); System.out.println("equals--" + c.equals(d));//true System.out.println(c == d);//false //valueOf Integer e = Integer.valueOf(100); Integer f = Integer.valueOf(100); System.out.println("equals--" + e.equals(f));//true System.out.println(e == f);//true //valueOf Integer m = Integer.valueOf(200); Integer n = Integer.valueOf(200); System.out.println("equals--" + m.equals(n));//true System.out.println(m == n);//false } 

根據註釋來看，equals比較之後都是true，這很好理解。因為Integer重寫了equals方法，只要內容相同，equals比較就是true。再者new方式產出的物件用”=“比較肯定是false，但是為什麼同樣是valueOf，一個是true，而另一個卻是false？？？！！！

不要急，看看Integer原始碼：

public static Integer valueOf(int i) { if(i >= -128 && i <= IntegerCache.high) return IntegerCache.cache[i + 128]; else return new Integer(i); } 

IntegerCache是靜態內部類。從原始碼可以看出使用valueOf方法建立Integer例項時：

當這個值在-128和127之間時，會用快取儲存起來，供多次使用，以節約記憶體。 
如果不在這個範圍內，則建立一個新的Integer物件。 再看一個例項：

//自動裝箱 Integer a = 200; Integer b = 200; System.out.println("equals--" + a.equals(b));//true System.out.println(a == b);//false 

暈。。居然false，why？？？？

反編譯一下這段程式碼，看看它神祕的面紗。

Integer a = Integer.valueOf(100); Integer b = Integer.valueOf(100); System.out.println("equals--" + a.equals(b)); System.out.println(a == b); Integer c = Integer.valueOf(200); Integer d = Integer.valueOf(200); System.out.println("equals--" + c.equals(d)); System.out.println(c == d); 

哦，原來如此。自動裝箱使用的就是valueOf方法，額的神啊！那麼自動拆箱是什麼原理？

Integer b = 100; int a = b; //反編譯 Integer b = Integer.valueOf(100); int a = b.intValue(); 

另外，算是提示吧？！

初始化一個字串，  String s1 = "s1"; 這樣的程式碼肯定比  String s2 = new String("s2");程式碼強，將其他型別的值轉換成String的時候，valueof方法比new方法效率也高。 

文章到此為止，希望對你有用！

非常感謝：

這篇文章引用了他們的某些程式碼片段，如果不是他們的無私奉獻，估計我沒有勇氣和能力寫出這篇文章，再次感謝他們，向他們學習！！！