java里面的高精度運算

package com.lv.study.am.first;

import java.math.BigDecimal;

public class TestBigDecimal {

    public static void main(String[] args) {

        // double d1=1.0;
        // double d2=0.9;

        // System.out.println(d1-d2);//0.1

        // 計算機語言-》 二進制 01

        // 計算10/3

        // 漏洞 吧小數點后小於2角的全部打到自己的賬號里面

        // test1();
        // test3();
        test4();

    }

    // 減法
    public static void test4() {
        BigDecimal bd1 = new BigDecimal(1.0);// 這個類沒有無參的構造器
        BigDecimal bd2 = new BigDecimal(0.9999);

        BigDecimal result = bd1.subtract(bd2);//

        System.out.println(result.floatValue());// 得到浮點類型
        System.out.println(result.intValue());//得到int類型
        System.out.println(result.longValue());

        System.out.println(result.setScale(10,BigDecimal.ROUND_HALF_UP));
        
        System.out.printf("%");
    }

    // 乘法
    public static void test3() {
        BigDecimal bd1 = new BigDecimal(1.0);// 這個類沒有無參的構造器
        BigDecimal bd2 = new BigDecimal(0.9);

        BigDecimal result = bd1.multiply(bd2);//

        System.out.println(result.floatValue());// 得到浮點類型
        System.out.println(result.intValue());
    }

    // 加法
    public static void test2() {
        BigDecimal bd1 = new BigDecimal(1.0);// 這個類沒有無參的構造器
        BigDecimal bd2 = new BigDecimal(0.9);

        BigDecimal result = bd1.add(bd2);// 做加法

        System.out.println(result.floatValue());// 得到浮點類型
        System.out.println(result.intValue());
    }

    public static void test1() {

        BigDecimal bd1 = new BigDecimal(1.0);// 這個類沒有無參的構造器
        BigDecimal bd2 = new BigDecimal(0.9);

        // 在計算時候沒有指定余下多少位小數和他的小數怎么進位就會報異常
        // System.out.println(bd1.divide(bd2).setScale(2,BigDecimal.ROUND_HALF_UP));//
        // 1/0.9->1.1111111

        // bd1： 被除數 bd2： 除數 2：留下的幾位小數 ROUND_HALF_UP ：四舍五入
        System.out.println(bd1.divide(bd2, 2, BigDecimal.ROUND_HALF_UP));// 靜態常量所有字母大寫

        // 一般涉及到比較敏感的金額不會用double
        Double d1 = new Double(1.0);
        Double d2 = new Double(0.9);

        // 除法運算
        // System.out.println(d1/d2);
        // System.out.println(d1+d2);
        // System.out.println(d1-d2);
        // System.out.println(d1*d2);
    }

}

下面具體講解

BigDecimal類處理高精度計算
Java在java.math包中提供的API類BigDecimal，用來對超過16位有效位的數進行精確的運算。雙精度浮點型變量double可以處理16位有效數，但在實際應用中，可能需要對更大或者更小的數進行運算和處理。一般情況下，對於那些不需要准確計算精度的數字，我們可以直接使用Float和Double處理，但是Double.valueOf(String) 和Float.valueOf(String)會丟失精度。所以開發中，如果我們需要精確計算的結果，則必須使用BigDecimal類來操作啦！

（一）BigDecimal類的常用的幾個構造方法

BigDecimal(int)：將int表示形式轉換為BigDecimal對象
BigDecimal(String) ：將字符串表示形式轉換為BigDecimal對象
BigDecimal(double)：將double表示形式轉換為BigDecimal對象
（二）BigDecimal類的常用方法

add(BigDecimal)：BigDecimal對象中的值相加，返回BigDecimal對象
subtract(BigDecimal)：BigDecimal對象中的值相減，返回BigDecimal對象
multiply(BigDecimal)：BigDecimal對象中的值相乘，返回BigDecimal對象
divide(BigDecimal)：BigDecimal對象中的值相除，返回BigDecimal對象
toString()：將BigDecimal對象中的值轉換成字符串
doubleValue()：將BigDecimal對象中的值轉換成雙精度數
floatValue()：將BigDecimal對象中的值轉換成單精度數
longValue()：將BigDecimal對象中的值轉換成長整數
intValue()：將BigDecimal對象中的值轉換成整數

//常用的;一般情況下,使用的都是四舍五入
BigDecimal.ROUND_HALF_UP表示四舍五入，
BigDecimal.ROUND_HALF_DOWN也是五舍六入，
BigDecimal.ROUND_UP表示進位處理（就是直接加1），
BigDecimal.ROUND_DOWN表示直接去掉尾數。
1: 加減乘除
BigDecimal bignum1 = new BigDecimal("10");  
BigDecimal bignum2 = new BigDecimal("5");  
BigDecimal bignum3 = null;  
  
//加法  
bignum3 =  bignum1.add(bignum2);       
System.out.println("和 是：" + bignum3);  
  
//減法  
bignum3 = bignum1.subtract(bignum2);  
System.out.println("差  是：" + bignum3);  
  
//乘法  
bignum3 = bignum1.multiply(bignum2);  
System.out.println("積  是：" + bignum3);  
  
//除法  
bignum3 = bignum1.divide(bignum2);  
System.out.println("商  是：" + bignum3); 

2: 比較大小

BigDecimal a = new BigDecimal (888);
BigDecimal b = new BigDecimal (666);
 
//使用compareTo方法比較
//注意：a、b均不能為null，否則會報空指針
if(a.compareTo(b) == -1){
    System.out.println("a小於b");
}
 
if(a.compareTo(b) == 0){
    System.out.println("a等於b");
}
 
if(a.compareTo(b) == 1){
    System.out.println("a大於b");
}
 
if(a.compareTo(b) > -1){
    System.out.println("a大於等於b");
}
 
if(a.compareTo(b) < 1){
    System.out.println("a小於等於b");

// 四舍五入  保留兩位小數
new BigDecimal("1024.1234").setScale(2,BigDecimal.ROUND_HALF_UP);



//默認除法運算精度
    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();
    }
 
    /**
     * 提供（相對）精確的除法運算，當發生除不盡的情況時，精確到
     * 小數點以后10位，以后的數字四舍五入
     *
     * @param v1 被除數
     * @param v2 除數
     * @return 兩個參數的商
     */
 
    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }
 
    /**
     * 提供（相對）精確的除法運算。當發生除不盡的情況時，由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();
    }
 
    /**
     * 提供（相對）精確的除法運算。當發生除不盡的情況時，由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;
    }