在Java程式設計過程中，經常會涉及到不同數值型別之間的計算問題，例如：

int m=6;  
float n=3.5f;  
double p=2.75d;
System.out.println(m + n); 
System.out.println(n + p);

執行程式，輸出結果分別為：9.5和6.25。計算機在執行m+n的時候，首先會將m先轉換成float型別，然後再將其與n進行加法運算。同理，執行n+p時，首先將n轉換成double型別，然後再將其與p進行加法運算。下面我們來看一下實際編碼過程中出現的問題：

我們可以看出，當兩個不同型別的數進行基本運算子操作時，精度小的數值型別首先會向精度大的數值型別進行轉換，最後進行計算。下面來看下數值型別之間的合法轉換圖。

圖中的實線箭頭表示有資訊丟失的轉換，虛線箭頭表示無資訊丟失的轉換。其轉換規則如下：

• 如果兩個運算元中有一個是double型別，另一個就會轉換為double型別；
• 否則，如果有一個運算元是float，另一個就會轉化為float；
• 否則，如果有一個運算元是long，另一個就會轉換為long；

• 否則，兩個運算元都將轉換為int型別。

  為了理解這些規則，這裡再舉幾個例子：

public class MyJava {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int
 
 a=6;  
        float b=3.5f;  
        double c =5.26d;
        long d=82l;   
        short e=2;  
        byte f=3; 
        System.out.println(a + b);
        System.out.println(a + c);
        System.out.println(a + d);
        System.out.println(a + e);
        System.out.println(a + f);
        System.out.println(b + c);
        System.out.println(b + d);
        System.out.println(b + e);
        System.out.println(b + f);
        System.out.println(c + d);
        System.out.println(c + e);
        System.out.println(c + f);
        System.out.println(d + e);
        System.out.println(d + f);
        System.out.println(e + f);
    }

}
 

輸出結果為：

9.5
11.26
88
8
9
8.76
85.5
5.5
6.5
87.26
7.26
8.26
84
85
5

接下來我們再看下數值之間計算時候存在的計算精度丟失問題。例子如下所示：

public class MyJava {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int a = 3;
        double b = 0.03;
        double c = 0.03;
        double d = a+b+c;
        System.out.println("d:" + d); 
    }

} 

輸出結果為：

d:3.0599999999999996

這裡我們可以看到最後的結果並不是我們預期的那樣為3.06，其實double型別數值的計算經常會出現這種精度丟失的問題，尤其是有小數點的情況下，常常會應為精度丟失而導致程式出錯。那麼該如何解決這個問題呢？這時候我們需要使用位於java.math包中的BigDecima類並用String來構造。具體使用方法如下：

    /** 
     * @param m1 
     * @param m2 
     * @return 
     */ 
    public static double add(double m1, double m2) {
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.add(p2).doubleValue();
    }

    /** 
     * @param m1 
     * @param m2 
     * @return 
     */ 
    public static double sub(double m1, double m2) {
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.subtract(p2).doubleValue();
    }

    /** 
     * @param m1 
     * @param m2 
     * @return 
     */ 
    public static double mul(double m1, double m2) {
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.multiply(p2).doubleValue();
    }


     /**    
      *   @param   m1  
      *   @param   m2        
      *   @param   scale      
      *   @return     
      */     
    public static double div(double m1, double m2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("Parameter error");
        }
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.divide(p2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    } 

以上就是問題的處理方法了。