Java BigDecimal 解决两个double相加控制小数位数的东东

悠悠 2022-06-14 01:26 224阅读 0赞

**BigDecimal 由任意精度的整数非标度值 和 32 位的整数标度 (scale) 组成。如果为零或正数，则标度是小数点后的位数。如果为负数，则将该数的非标度值乘以 10 的负 scale 次幂。因此，BigDecimal 表示的数值是 (unscaledValue × 10-scale)。 **  
  
**可以处理任意长度的浮点数运算。 **  
  
**BigDecimal add(BigDecimal val) //BigDecimal 加法 **  
  
**BigDecimal subtract (BigDecimal val) //BigDecimal 减法 **  
  
**BigDecimal multiply (BigDecimal val)  //BigDecimal 乘法 **  
  
**BigDecimal divide (BigDecimal val,RoundingMode mode)  除法 **  
  
  
**具体使用 计算： **  
**　　加:   a.add(b); **  
**　　减: a.subtract(b); **  
**　　乘:   a.multiply(b); **  
**　　除:   a.divide(b,2);//2为精度取值 **  
**除法细解： **  
**  //注意以下相除会抛出异常,原因: 通过BigDecimal的divide方法进行除法时当不整除，出现无限循环小数时，就会抛异常  **  
**        //BigDecimal divideBg = a.divide(b);   **  
**        //解决方法是：设置精确度;就是给divide设置精确的小数点 **  
**divide(xxxxx,2, BigDecimal.ROUND\_HALF\_EVEN)   **  
**        //其中的第二个参数表示的是：保留小数点之后多少位  **  
  
**BigDecimal不整除抛出的异常,请设置精确度！ **  
**Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result. **  
**at java.math.BigDecimal.divide(BigDecimal.java:1278) **  
**at main.Main.main(Main.java:41) **  
  
**下面我们来看看除法的详细说明： **  
**   divide(BigDecimal divisor, int scale, introundingMode) **  
  
**BigDecimal的setScale方法 **  
  
**BigDecimal.setScale() **  
  
**方法用于格式化小数点 **  
  
**表示保留一位小数，默认用四舍五入方式 **  
  
**setScale(1) **  
  
**直接删除多余的小数位，如2.35会变成2.3 setScale(1,BigDecimal.ROUND\_DOWN) **  
  
**进位处理，2.35变成2.4  setScale(1,BigDecimal.ROUND\_UP) **  
  
**四舍五入，2.35变成2.4  setScale(1,BigDecimal.ROUND\_HALF\_UP) **  
  
**四舍五入，2.35变成2.3，如果是5则向下舍setScaler(1,BigDecimal.ROUND\_HALF\_DOWN) **  
  
**注意点一 **  
  
**scale指的是你小数点后的位数。 **  
**scale()就是BigDecimal类中的方法。如 **  
  
**BigDecimal b = new BigDecimal("123.456"); **  
  
**b.scale()返回的就是3 **  
**注意点二roundingMode是小数的保留模式。它们都是BigDecimal中的常量字段, **  
  
**有很多种，如 **  
**BigDecimal.ROUND\_HALF\_UP表示的就是4舍5入 **  
  
**注意点三 **  
  
**divide(BigDecimal divisor, int scale, introundingMode)的意思是说： **  
**我用一个BigDecimal对象除以divisor后的结果，并且要求这个结果保留有scale个小数位，roundingMode表示的就是保留模式是什么，是四舍五入啊还是其它的 **  
  
  
**BigDecimal aa = new  BigDecimal(135.95 );  **  
  
**BigDecimal bb=new  BigDecimal("100" );  **  
  
**BigDecimal result=aa.multiply(bb);  //做加法 **  
  
  
  
**3.java中 BigDecimal类型的可以转换到double类型： **  
**  用 变量.doubleValue();函数  即可将 BigDecimal 类型数据 转化为 double类型！ **  
**4.java BigDecimal比较大小 **  
  
**可以通过BigDecimal的compareTo方法来进行比较。 **  
**返回的结果是int类型，-1表示小于，0是等于，1是大于。 **  
  
**看下面这个例子： **  
**BigDecimal a = new BigDecimal("1.00"); **  
**BigDecmial b = new BigDecimal(1); **  
  
**想比较一下a和b的大小，一般都会用equals **  
  
**System.out.println(a.equals(b)); **  
**但是输出结果是：false **  
**原因是：BigDecimal比较时，不仅比较值，而且还比较精度？ **  
  
  
**if(a.compareTo(b)==0) 结果是true **  
  
**比较大小可以用 a.compareTo(b) **  
**返回值    -1 小于   0 等于    1 大于 **  
  
**5.BigDecimal取其中最大、最小值、绝对值、相反数: **  
  
**　　a.max (b) //比较取最大值 **  
  
**　　a.min(b) //比较取最小值 **  
  
**　　a.abs()//取最绝对值 **  
  
**　　a.negate()//取相反数 **  
  
  
**6.下面是注意 ： **  
  
**BigDecimal枚举常量用法摘要  ： **  
  
**CEILING   **  
**          向正无限大方向舍入的舍入模式。 **  
**DOWN   **  
**          向零方向舍入的舍入模式。 **  
**FLOOR   **  
**          向负无限大方向舍入的舍入模式。 **  
**HALF\_DOWN   **  
**          向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。 **  
**HALF\_EVEN   **  
**          向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。 **  
**HALF\_UP   **  
**          向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。 **  
**UNNECESSARY   **  
**          用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。 **  
**UP   **  
**          远离零方向舍入的舍入模式。 **  
  
**7.关于BigDecimal格式化 **  
  
**public String formatValue(Object value)\{ **  
**        String content = null; **  
**        if (value == null) \{ **  
**             content = ""; **  
**         \} else \{ **  
**             if(value instanceof BigDecimal)\{ **  
**                 //conver to fortmat String **  
**                 NumberFormat nf = NumberFormat.getInstance(); **  
**                 nf.setMinimumFractionDigits(2); **  
**                 nf.setMaximumFractionDigits(2); **  
**                 content = nf.format(value);  **  
**             \}else\{ **  
**                 content = String.valueOf(value); **  
**             \} **  
**         \} **  
**        return content; **  
**    \} **  
  
**使用这样一个方法可以达到格式化的效果，其中value instanceof BigDecimal，表示的是字符类型是BigDecimal类型的时候执行，这里的NumberFormat就表示字符类型，下面的两句代码就表示小数点后面的精确位数。 **  
  
**这里还要提到NumberFormat的其他两个类型： **  
  
**getCurrencyInstance()： 返回当前默认 环境的货币格式 **  
  
**CurrencyInstance（）： 返回指定语言 环境的数字格式，一般是百分比格式 **

============================================================================================================================================

1.  **public** **class** DoubleOperationUtil \{  
2.      //默认除法运算精度     
3.      **private**   **static**   **final**   **int**   DEF\_DIV\_SCALE   =   10;     
4.      //这个类不能实例化     
5.      **private**   DoubleOperationUtil()\{     
6.      \}     
7.      /\*\*    
8.        \*   提供精确的加法运算。    
9.        \*   @param   v1   被加数    
10.       \*   @param   v2   加数    
11.       \*   @return   两个参数的和    
12.       \*/     
13.   
14.     **public**   **static**   **double**   add(**double**   v1,**double**   v2)\{     
15.             BigDecimal   b1   =   **new**   BigDecimal(Double.toString(v1));     
16.             BigDecimal   b2   =   **new**   BigDecimal(Double.toString(v2));     
17.             **return**   b1.add(b2).doubleValue();     
18.     \}     
19.   
20.     /\*\*    
21.       \*   提供精确的减法运算。    
22.       \*   @param   v1   被减数    
23.       \*   @param   v2   减数    
24.       \*   @return   两个参数的差    
25.       \*/     
26.   
27.     **public**   **static**   **double**   sub(**double**   v1,**double**   v2)\{     
28.             BigDecimal   b1   =   **new**   BigDecimal(Double.toString(v1));     
29.             BigDecimal   b2   =   **new**   BigDecimal(Double.toString(v2));     
30.             **return**   b1.subtract(b2).doubleValue();     
31.     \}       
32.   
33.     /\*\*    
34.       \*   提供精确的乘法运算。    
35.       \*   @param   v1   被乘数    
36.       \*   @param   v2   乘数    
37.       \*   @return   两个参数的积    
38.       \*/     
39.   
40.     **public**   **static**   **double**   mul(**double**   v1,**double**   v2)\{     
41.             BigDecimal   b1   =   **new**   BigDecimal(Double.toString(v1));     
42.             BigDecimal   b2   =   **new**   BigDecimal(Double.toString(v2));     
43.             **return**   b1.multiply(b2).doubleValue();     
44.     \}     
45.   ==============================================================================================
46.   
47.   
48.     /\*\*    
49.       \*   提供（相对）精确的除法运算，当发生除不尽的情况时，精确到    
50.       \*   小数点以后10位，以后的数字四舍五入。    
51.       \*   @param   v1   被除数    
52.       \*   @param   v2   除数    
53.       \*   @return   两个参数的商    
54.       \*/     
55.   
56.     **public**   **static**   **double**   div(**double**   v1,**double**   v2)\{     
57.             **return**   div(v1,v2,DEF\_DIV\_SCALE);     
58.     \}     
59.   
60.     /\*\*    
61.       \*   提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指    
62.       \*   定精度，以后的数字四舍五入。    
63.       \*   @param   v1   被除数    
64.       \*   @param   v2   除数    
65.       \*   @param   scale   表示表示需要精确到小数点以后几位。    
66.       \*   @return   两个参数的商    
67.       \*/     
68.   
69.     **public**   **static**   **double**   div(**double**   v1,**double**   v2,**int**   scale)\{     
70.             **if**(scale<0)\{     
71.                     **throw**   **new**   IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");     
72.             \}     
73.             BigDecimal   b1   =   **new**   BigDecimal(Double.toString(v1));     
74.             BigDecimal   b2   =   **new**   BigDecimal(Double.toString(v2));     
75.             **return**   b1.divide(b2,scale,BigDecimal.ROUND\_HALF\_UP).doubleValue();     
76.     \}     
77.   
78.   
79.   ===========================================================================================================
80.     /\*\*    
81.       \*   提供精确的小数位四舍五入处理。    
82.       \*   @param   v   需要四舍五入的数字    
83.       \*   @param   scale   小数点后保留几位    
84.       \*   @return   四舍五入后的结果    
85.       \*/     
86.   
87.     **public**   **static**   **double**   round(**double**   v,**int**   scale)\{     
88.             **if**(scale<0)\{     
89.                     **throw**   **new**   IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");     
90.             \}     
91.             BigDecimal   b   =   **new**   BigDecimal(Double.toString(v));     
92.             BigDecimal   one   =   **new**   BigDecimal("1");     
93.             **return**   b.divide(one,scale,BigDecimal.ROUND\_HALF\_UP).doubleValue();     
94.     \}     
95.   
96. \}

============================================================================================================================================

## 3.1构造函数（主要测试参数类型为double和String的两个常用构造函数） ##

BigDecimal aDouble =**new** BigDecimal(1.22);

System.*out*.println("construct with a double value: " + aDouble);

BigDecimal aString = **new** BigDecimal("1.22");

System.*out*.println("construct with a String value: " + aString);

你认为输出结果会是什么呢？如果你没有认为第一个会输出1.22，那么恭喜你答对了，输出结果如下：

construct with a doublevalue:1.2199999999999999733546474089962430298328399658203125

construct with a String value: 1.22

JDK的描述：1、参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

2、另一方面，String 构造方法是完全可预知的：写入 newBigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，**通常建议优先使用[String构造方法][String]**。

3、当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用[`Double.toString(double)`][String]方法，然后使用[`BigDecimal(String)`][String]构造方法，将double转换为String。要获取该结果，请使用static [`valueOf(double)`][String]方法。

## 3.2 加法操作 ##

BigDecimal a =**new** BigDecimal("1.22");

System.*out*.println("construct with a String value: " + a);

BigDecimal b =**new** BigDecimal("2.22");

a.add(b);

System.*out*.println("aplus b is : " + a);

我们很容易会认为会输出：

construct with a Stringvalue: 1.22

a plus b is :3.44

但实际上a plus b is : 1.22

# 4.源码分析 #

## 4.1 valueOf(doubleval)方法 ##

**    public   static** BigDecimal valueOf(**double** val) \{

// Reminder: a zero double returns '0.0', so we cannotfastpath

// to use the constant ZERO. This might be important enough to

// justify a factory approach, a cache, or a few private

// constants, later.

**returnnew** BigDecimal(Double.*toString*(val));

## 4.2 add(BigDecimal augend)方法 ##

**      public** BigDecimal   add(BigDecimal augend) \{

**long** xs =**this**.intCompact; //整型数字表示的BigDecimal,例a的intCompact值为122

**long** ys = augend.intCompact;//同上

BigInteger fst = (**this**.intCompact !=*INFLATED*) ?**null** :**this**.intVal;//初始化BigInteger的值，intVal为BigDecimal的一个BigInteger类型的属性

BigInteger snd =(augend.intCompact !=*INFLATED*) ?**null** : augend.intVal;

**int** rscale =**this**.scale;//小数位数

**long** sdiff = (**long**)rscale - augend.scale;//小数位数之差

**if** (sdiff != 0) \{ //取小数位数多的为结果的小数位数

**if** (sdiff < 0) \{

**int** raise =checkScale(-sdiff);

rscale =augend.scale;

**if** (xs ==*INFLATED* ||

(xs = *longMultiplyPowerTen*(xs,raise)) ==*INFLATED*)

fst =bigMultiplyPowerTen(raise);

\}**else** \{

**int** raise =augend.checkScale(sdiff);

**if** (ys ==*INFLATED* ||(ys =*longMultiplyPowerTen*(ys,raise)) ==*INFLATED*)

snd = augend.bigMultiplyPowerTen(raise);

**if** (xs !=*INFLATED* && ys !=*INFLATED*) \{

**long** sum = xs + ys;

**if** ( (((sum ^ xs) &(sum ^ ys))) >= 0L)//判断有无溢出

**return** BigDecimal.*valueOf*(sum,rscale);//返回使用BigDecimal的静态工厂方法得到的BigDecimal实例

**if** (fst ==**null**)

fst =BigInteger.*valueOf*(xs);//BigInteger的静态工厂方法

**if** (snd ==**null**)

snd =BigInteger.*valueOf*(ys);

BigInteger sum =fst.add(snd);

**return** (fst.signum == snd.signum) ?**new** BigDecimal(sum,*INFLATED*, rscale, 0) :

**new** BigDecimal(sum,*compactValFor*(sum),rscale, 0);//返回通过其他构造方法得到的BigDecimal对象

以上只是对加法源码的分析，减乘除其实最终都返回的是一个新的BigDecimal对象，因为BigInteger与BigDecimal都是不可变的（immutable）的，在进行每一步运算时，都会产生一个新的对象，所以a.add(b);虽然做了加法操作，但是a并没有保存加操作后的值，正确的用法应该是a=a.add(b);

# 5.总结 #

BigDecimal都是不可变的（immutable）的，在进行每一步运算时，都会产生一个新的对象，所以在做加减乘除运算时千万要保存操作后的值。

[String]: http://blog.csdn.net/jackiehff/article/details/8582449