欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

java中BigDecimal的使用踩坑記錄

 更新時間：2023年10月08日 09:20:02   作者：myprincess003  
這篇文章主要為大家詳細介紹了java中使用BigDecimal會踩坑的地方以及相關(guān)的解決方法,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下

一、踩坑記錄

踩坑一：創(chuàng)建 BigDecimal精度丟失的坑

在BigDecimal 中提供了多種創(chuàng)建方式，可以通過new 直接創(chuàng)建，也可以通過 BigDecimal#valueOf 創(chuàng)建。這兩種方式使用不當(dāng)，也會導(dǎo)致精度問題。如下：

public static void main(String[] args) throws Exception {
   BigDecimal b1= new BigDecimal(0.1);
   System.out.println(b1);
   BigDecimal b2= BigDecimal.valueOf(0.1);
   System.out.println(b2);
   BigDecimal b3= BigDecimal.valueOf(0.111111111111111111111111111234);
   System.out.println(b3);
}

執(zhí)行結(jié)果：

0.1000000000000000055511151231257827021181583404541015625
0.1
0.1111111111111111

上面示例中兩個方法都傳入了double類型的參數(shù)0.1但是 b1 還是出現(xiàn)了精度的問題。造成這種問題的原因是 0.1 這個數(shù)字計算機是無法精確表示的，送給 BigDecimal 的時候就已經(jīng)丟精度了，而 BigDecimal#valueOf 的實現(xiàn)卻完全不同。如下源碼所示，BigDecimal#valueOf 中是把浮點數(shù)轉(zhuǎn)換成了字符串來構(gòu)造的BigDecimal，因此避免了問題。

public static BigDecimal valueOf(double val) {
   return new BigDecimal(Double.toString(val));
}

結(jié)論：

第一，在使用BigDecimal構(gòu)造函數(shù)時，盡量傳遞字符串而非浮點類型；

第二，如果無法滿足第一條，則可采用BigDecimal#valueOf方法來構(gòu)造初始化值。但是valueOf受double類型精度影響，當(dāng)傳入?yún)?shù)小數(shù)點后的位數(shù)超過double允許的16位精度還是可能會出現(xiàn)問題的

踩坑二：等值比較的坑

一般在比較兩個值是否相等時，都是用equals 方法，但是，在BigDecimal 中使用equals可能會導(dǎo)致結(jié)果錯誤，BigDecimal 中提供了 compareTo 方法，在很多時候需要使用compareTo 比較兩個值。如下所示：

public static void main(String[] args){
    BigDecimal b1 = new BigDecimal("1.0");
    BigDecimal b2 = new BigDecimal("1.00");
    System.out.println(b1.equals(b2));
    System.out.println(b1.compareTo(b2));
}

執(zhí)行結(jié)果：

false
0

出現(xiàn)此種結(jié)果的原因是，equals不僅比較了值是否相等，還比較了精度是否相同。示例中，由于兩個值的精度不同，所有結(jié)果也就不相同。而 compareTo 是只比較值的大小。返回的值為-1（小于），0（等于），1（大于）。

結(jié)論

  • 如果比較兩個BigDecimal值的大小，采用其實現(xiàn)的compareTo方法；
  • 如果嚴格限制精度的比較，那么則可考慮使用equals方法。

踩坑三：無限精度的坑

BigDecimal 并不代表無限精度，當(dāng)在兩個數(shù)除不盡的時候，就會出現(xiàn)無限精度的坑，如下所示：

public static void main(String[] args){
   BigDecimal b1 = new BigDecimal("1.0");
    BigDecimal b2 = new BigDecimal("3.0");
    b1.divide(b2);
}

執(zhí)行結(jié)果：

Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
    at java.math.BigDecimal.divide(BigDecimal.java:1693)
    at com.demo.controller.Test.main(Test.java:29)

在官方文檔中對該異常有如下說明：

If the quotient has a nonterminating decimal expansion and the
operation is specified to return an exact result, an
ArithmeticException is thrown. Otherwise, the exact result of the
division is returned, as done for other operations.

大致意思就是，如果在除法（divide）運算過程中，如果商是一個無限小數(shù)（如 0.333…），而操作的結(jié)果預(yù)期是一個精確的數(shù)字，那么將會拋出ArithmeticException異常。

此種情況，只需要在使用 divide方法時指定結(jié)果的精度即可：

public static void main(String[] args){
   BigDecimal b1 = new BigDecimal("1.0");
   BigDecimal b2 = new BigDecimal("3.0");
   System.out.println(b1.divide(b2,2, RoundingMode.HALF_UP));//0.33
}

結(jié)論：

在使用BigDecimal進行（所有）運算時，盡量指定精度和舍入模式。

踩坑四：BigDecimal三種字符串輸出的坑

在BigDecimal 轉(zhuǎn)換成字符串時，有可能輸出非你預(yù)期的結(jié)果。如下所示：

public static void main(String[] args){
   BigDecimal bg = new BigDecimal("1E11");
    System.out.println(bg.toString()); // 1E+11
    System.out.println(bg.toPlainString()); // 100000000000
    System.out.println(bg.toEngineeringString()); // 100E+9
}

執(zhí)行結(jié)果：

1E+11
100000000000
100E+9

可以看到三種方式輸出的結(jié)果可能都不相同，可能這個并不是預(yù)期的結(jié)果 ，BigDecimal 有三個方法可以轉(zhuǎn)為相應(yīng)的字符串類型，切記不要用錯：

以下內(nèi)容介紹java.math.BigDecimal下的三個toString方法的區(qū)別及用法

  • toPlainString() : 不使用任何指數(shù)。
  • toString() ：有必要時使用科學(xué)計數(shù)法。
  • toEngineeringString()：有必要時使用工程計數(shù)法。 工程記數(shù)法是一種工程計算中經(jīng)常使用的記錄數(shù)字的方法，與科學(xué)技術(shù)法類似，但要求10的冪必須是3的倍數(shù)

踩坑五：使用BigDecimal進行計算時參數(shù)不能為NULL

在使用BigDecimal類型進行計算時，進行加、減、乘、除、比較大小時，一定要保證參與計算的兩個值不能為空，否則會拋出java.lang.NullPointerException異常。

代碼示例：

BigDecimal b1 = new BigDecimal("1");
BigDecimal b2 = null;
System.out.println("相加："+b2.add(b1));

結(jié)果：

Exception in thread "main" java.lang.NullPointerException
    at com.demo.controller.Test.main(Test.java:14)

踩坑六：使用BigDecimal進行除法計算時被除數(shù)不能為0

代碼示例：

BigDecimal b1 = new BigDecimal("1");
BigDecimal b2 = new BigDecimal("0");
System.out.println(b1.divide(b2));

執(zhí)行結(jié)果：

Exception in thread "main" java.lang.ArithmeticException: Division by zero

踩坑七：執(zhí)行順序不能調(diào)換（乘法交換律失效）

乘法滿足交換律是一個常識，但是在計算機的世界里，會出現(xiàn)不滿足乘法交換律的情況；

代碼示例：

BigDecimal b1 = BigDecimal.valueOf(1.0);
BigDecimal b2 = BigDecimal.valueOf(3.0);
BigDecimal b3 = BigDecimal.valueOf(3.0);
System.out.println(b1.divide(b2, 2, RoundingMode.HALF_UP).multiply(b3)); // 0.990
System.out.println(b1.multiply(b3).divide(b2, 2, RoundingMode.HALF_UP)); // 1.00

執(zhí)行結(jié)果：

0.990
1.00

執(zhí)行順序交換后，產(chǎn)生的結(jié)果可能不同，會導(dǎo)致一定的問題，使用順序建議先乘后除。

二、BigDecimal概述

Java在java.math包中提供的API類BigDecimal，用來對超過16位有效位的數(shù)進行精確的運算。雙精度浮點型變量double可以處理16位有效數(shù)，但在實際應(yīng)用中，可能需要對更大或者更小的數(shù)進行運算和處理。

一般情況下，對于那些不需要準(zhǔn)確計算精度的數(shù)字，我們可以直接使用Float和Double處理，但是Double.valueOf(String) 和Float.valueOf(String)會丟失精度。所以開發(fā)中，如果我們需要精確計算的結(jié)果，則必須使用BigDecimal類來操作。

BigDecimal所創(chuàng)建的是對象，故我們不能使用傳統(tǒng)的+、-、*、/等算術(shù)運算符直接對其對象進行數(shù)學(xué)運算，而必須調(diào)用其相對應(yīng)的方法。方法中的參數(shù)也必須是BigDecimal的對象。構(gòu)造器是類的特殊方法，專門用來創(chuàng)建對象，特別是帶有參數(shù)的對象。

三、BigDecimal常用構(gòu)造函數(shù)

3.1、常用構(gòu)造函數(shù)

BigDecimal(int)

創(chuàng)建一個具有參數(shù)所指定整數(shù)值的對象

BigDecimal(double)

創(chuàng)建一個具有參數(shù)所指定雙精度值的對象

BigDecimal(long)

創(chuàng)建一個具有參數(shù)所指定長整數(shù)值的對象

BigDecimal(String)

創(chuàng)建一個具有參數(shù)所指定以字符串表示的數(shù)值的對象

3.2、使用問題分析

使用示例：

BigDecimal a =new BigDecimal(0.1);
System.out.println("a values is:"+a);
System.out.println("=====================");
BigDecimal b =new BigDecimal("0.1");
System.out.println("b values is:"+b);

結(jié)果示例：

a values is:0.1000000000000000055511151231257827021181583404541015625
=====================
b values is:0.1

原因分析：

1）參數(shù)類型為double的構(gòu)造方法的結(jié)果有一定的不可預(yù)知性。有人可能認為在Java中寫入newBigDecimal(0.1)所創(chuàng)建的BigDecimal正好等于 0.1（非標(biāo)度值 1，其標(biāo)度為 1），但是它實際上等于0.1000000000000000055511151231257827021181583404541015625。這是因為0.1無法準(zhǔn)確地表示為 double（或者說對于該情況，不能表示為任何有限長度的二進制小數(shù)）。這樣，傳入到構(gòu)造方法的值不會正好等于 0.1（雖然表面上等于該值）。

2）String 構(gòu)造方法是完全可預(yù)知的：寫入 newBigDecimal(“0.1”) 將創(chuàng)建一個 BigDecimal，它正好等于預(yù)期的 0.1。因此，比較而言， 通常建議優(yōu)先使用String構(gòu)造方法。

3）當(dāng)double必須用作BigDecimal的源時，請注意，此構(gòu)造方法提供了一個準(zhǔn)確轉(zhuǎn)換；它不提供與以下操作相同的結(jié)果：先使用Double.toString(double)方法，然后使用BigDecimal(String)構(gòu)造方法，將double轉(zhuǎn)換為String。要獲取該結(jié)果，請使用static valueOf(double)方法。

四、BigDecimal常用方法詳解

4.1、常用方法

1.add(BigDecimal)

BigDecimal對象中的值相加，返回BigDecimal對象

2.subtract(BigDecimal)

BigDecimal對象中的值相減，返回BigDecimal對象

3.multiply(BigDecimal)

BigDecimal對象中的值相乘，返回BigDecimal對象

4.divide(BigDecimal)

BigDecimal對象中的值相除，返回BigDecimal對象

5.toString()

將BigDecimal對象中的值轉(zhuǎn)換成字符串

6.doubleValue()

將BigDecimal對象中的值轉(zhuǎn)換成雙精度數(shù)

7.floatValue()

將BigDecimal對象中的值轉(zhuǎn)換成單精度數(shù)

8.longValue()

將BigDecimal對象中的值轉(zhuǎn)換成長整數(shù)

9.intValue()

將BigDecimal對象中的值轉(zhuǎn)換成整數(shù)

4.2、BigDecimal大小比較

java中對BigDecimal比較大小一般用的是bigdemical的compareTo方法

int a = bigdemical.compareTo(bigdemical2)

返回結(jié)果分析：

a = -1,表示bigdemical小于bigdemical2；

a = 0,表示bigdemical等于bigdemical2；

a = 1,表示bigdemical大于bigdemical2；

舉例：a大于等于b

new bigdemica(a).compareTo(new bigdemical(b)) >= 0

五、BigDecimal格式化

由于NumberFormat類的format()方法可以使用BigDecimal對象作為其參數(shù)，可以利用BigDecimal對超出16位有效數(shù)字的貨幣值，百分值，以及一般數(shù)值進行格式化控制。

以利用BigDecimal對貨幣和百分比格式化為例。首先，創(chuàng)建BigDecimal對象，進行BigDecimal的算術(shù)運算后，分別建立對貨幣和百分比格式化的引用，最后利用BigDecimal對象作為format()方法的參數(shù)，輸出其格式化的貨幣值和百分比。

NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立貨幣格式化引用
NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用
percent.setMaximumFractionDigits(3); //百分比小數(shù)點最多3位
BigDecimal loanAmount = new BigDecimal("15000.48"); //貸款金額
BigDecimal interestRate = new BigDecimal("0.008"); //利率
BigDecimal interest = loanAmount.multiply(interestRate); //相乘
System.out.println("貸款金額:\t" + currency.format(loanAmount));
System.out.println("利率:\t" + percent.format(interestRate));
System.out.println("利息:\t" + currency.format(interest));

結(jié)果：

貸款金額: ￥15,000.48 利率: 0.8% 利息: ￥120.00
BigDecimal格式化保留2為小數(shù)，不足則補0：

public class NumberFormat {
    public static void main(String[] s){
        System.out.println(formatToNumber(new BigDecimal("3.435")));
        System.out.println(formatToNumber(new BigDecimal(0)));
        System.out.println(formatToNumber(new BigDecimal("0.00")));
        System.out.println(formatToNumber(new BigDecimal("0.001")));
        System.out.println(formatToNumber(new BigDecimal("0.006")));
        System.out.println(formatToNumber(new BigDecimal("0.206")));
    }
    /**
     * @desc 1.0~1之間的BigDecimal小數(shù)，格式化后失去前面的0,則前面直接加上0。
     * 2.傳入的參數(shù)等于0，則直接返回字符串"0.00"
     * 3.大于1的小數(shù)，直接格式化返回字符串
     * @param obj傳入的小數(shù)
     * @return
     */
    public static String formatToNumber(BigDecimal obj) {
        DecimalFormat df = new DecimalFormat("#.00");
        if(obj.compareTo(BigDecimal.ZERO)==0) {
            return "0.00";
        }else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){
            return "0"+df.format(obj).toString();
        }else {
            return df.format(obj).toString();
        }
    }
}

結(jié)果為：

3.44
0.00
0.00
0.00
0.01
0.21

六、BigDecimal常見異常

除法的時候出現(xiàn)異常

原因分析：

通過BigDecimal的divide方法進行除法時當(dāng)不整除，出現(xiàn)無限循環(huán)小數(shù)時，就會拋異常：java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

解決方法：

divide方法設(shè)置精確的小數(shù)點，如：divide(xxxxx,2)

七、BigDecimal總結(jié)

7.1、總結(jié)

在需要精確的小數(shù)計算時再使用BigDecimal，BigDecimal的性能比double和float差，在處理龐大，復(fù)雜的運算時尤為明顯。故一般精度的計算沒必要使用BigDecimal。

盡量使用參數(shù)類型為String的構(gòu)造函數(shù)。

BigDecimal都是不可變的（immutable）的， 在進行每一次四則運算時，都會產(chǎn)生一個新的對象，所以在做加減乘除運算時要記得要保存操作后的值。

7.2、工具類推薦

package com.vivo.ars.util;
import java.math.BigDecimal;
/**
 * 用于高精確處理常用的數(shù)學(xué)運算
 */
public class ArithmeticUtils {
    //默認除法運算精度
    private static final int DEF_DIV_SCALE = 10;
    /**
     * 提供精確的加法運算
     *
     * @param v1 被加數(shù)
     * @param v2 加數(shù)
     * @return 兩個參數(shù)的和
     */
    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 被加數(shù)
     * @param v2 加數(shù)
     * @return 兩個參數(shù)的和
     */
    public static BigDecimal add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2);
    }
    /**
     * 提供精確的加法運算
     *
     * @param v1    被加數(shù)
     * @param v2    加數(shù)
     * @param scale 保留scale 位小數(shù)
     * @return 兩個參數(shù)的和
     */
    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 被減數(shù)
     * @param v2 減數(shù)
     * @return 兩個參數(shù)的差
     */
    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 被減數(shù)
     * @param v2 減數(shù)
     * @return 兩個參數(shù)的差
     */
    public static BigDecimal sub(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2);
    }
    /**
     * 提供精確的減法運算
     *
     * @param v1    被減數(shù)
     * @param v2    減數(shù)
     * @param scale 保留scale 位小數(shù)
     * @return 兩個參數(shù)的差
     */
    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 被乘數(shù)
     * @param v2 乘數(shù)
     * @return 兩個參數(shù)的積
     */
    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 被乘數(shù)
     * @param v2 乘數(shù)
     * @return 兩個參數(shù)的積
     */
    public static BigDecimal mul(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2);
    }
    /**
     * 提供精確的乘法運算
     *
     * @param v1    被乘數(shù)
     * @param v2    乘數(shù)
     * @param scale 保留scale 位小數(shù)
     * @return 兩個參數(shù)的積
     */
    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    被乘數(shù)
     * @param v2    乘數(shù)
     * @param scale 保留scale 位小數(shù)
     * @return 兩個參數(shù)的積
     */
    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();
    }
    /**
     * 提供（相對）精確的除法運算，當(dāng)發(fā)生除不盡的情況時，精確到
     * 小數(shù)點以后10位，以后的數(shù)字四舍五入
     *
     * @param v1 被除數(shù)
     * @param v2 除數(shù)
     * @return 兩個參數(shù)的商
     */
    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }
    /**
     * 提供（相對）精確的除法運算。當(dāng)發(fā)生除不盡的情況時，由scale參數(shù)指
     * 定精度，以后的數(shù)字四舍五入
     *
     * @param v1    被除數(shù)
     * @param v2    除數(shù)
     * @param scale 表示表示需要精確到小數(shù)點以后幾位。
     * @return 兩個參數(shù)的商
     */
    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();
    }
    /**
     * 提供（相對）精確的除法運算。當(dāng)發(fā)生除不盡的情況時，由scale參數(shù)指
     * 定精度，以后的數(shù)字四舍五入
     *
     * @param v1    被除數(shù)
     * @param v2    除數(shù)
     * @param scale 表示需要精確到小數(shù)點以后幾位
     * @return 兩個參數(shù)的商
     */
    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();
    }
    /**
     * 提供精確的小數(shù)位四舍五入處理
     *
     * @param v     需要四舍五入的數(shù)字
     * @param scale 小數(shù)點后保留幾位
     * @return 四舍五入后的結(jié)果
     */
    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();
    }
    /**
     * 提供精確的小數(shù)位四舍五入處理
     *
     * @param v     需要四舍五入的數(shù)字
     * @param scale 小數(shù)點后保留幾位
     * @return 四舍五入后的結(jié)果
     */
    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();
    }
    /**
     * 取余數(shù)
     *
     * @param v1    被除數(shù)
     * @param v2    除數(shù)
     * @param scale 小數(shù)點后保留幾位
     * @return 余數(shù)
     */
    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();
    }
    /**
     * 取余數(shù)  BigDecimal
     *
     * @param v1    被除數(shù)
     * @param v2    除數(shù)
     * @param scale 小數(shù)點后保留幾位
     * @return 余數(shù)
     */
    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 被比較數(shù)
     * @param v2 比較數(shù)
     * @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;
    }
}

以上就是java中BigDecimal的使用踩坑記錄的詳細內(nèi)容，更多關(guān)于java BigDecimal的資料請關(guān)注腳本之家其它相關(guān)文章！

相關(guān)文章

最新評論