BigDecimal数据类型（初始化，加减乘除，基本操作）

冷不防 2022-11-25 05:25 146阅读 0赞

**BigDecimal为大数据类型，更精准的计算**

### 1.初始化 ###

1.  字符串做参数
    
        BigDecimal a =new BigDecimal(“1.22”);
        doublevalue:1.2199999999999999733546474089962430298328399658203125
2.  数字做参数
    
        BigDecimal a =new BigDecimal(1.22);
        construct with a String value: 1.22

*  **注意1：String 构造方法是完全可预知的：写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，通常建议优先使用String构造方法。**
 *  **注意2：当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法**

### 2.加减乘除操作 ###

1.  加法运算  
    a.add(b)
    
        BigDecimal a =new BigDecimal("1.22");
         BigDecimal b =new BigDecimal("2.22");
         a=a.add(b);
         System.out.println("aplus b is : " + a);
2.  减法运算  
    a.subtract(b)
    
        BigDecimal a =new BigDecimal("13.22");
         BigDecimal b =new BigDecimal("2.22");
         a=a.subtract(b);
         System.out.println(a);
3.  乘法运算  
    a.multiply(b)
    
        BigDecimal a =new BigDecimal("13.22");
         BigDecimal b =new BigDecimal("2.22");
         a=a.multiply(b);
         System.out.println(a);
4.  除法运算  
    a=a.divide(b,2)  
    a=a.divide(b,2,BigDecimal.’BigDecimal.舍入方式’)  
    2为保留小数点位数  
    BigDecimal.ROUND\_HALF\_EVEN为小数舍入方式，默认四舍五入
    
        BigDecimal a =new BigDecimal("13.22");
         BigDecimal b =new BigDecimal("2.22");
         a=a.divide(b,2);
         System.out.println(a);

**通过BigDecimal的divide方法进行除法时当不整除，出现无限循环小数时，就会抛异常 解决方法：给divide方法设置精度及保留几位小数**

### **舍入方式** ###

另外的一个计算问题，就是四舍五入。但是Java的计算本身是不能够支持四舍五入的，比如：

public class GetThrowTester {  
        public static void main(String args[]){  
            System.out.println(4.015 * 100.0);  
        }  
    }

这个输出为：  
401.49999999999994  
所以就会发现这种情况并不能保证四舍五入，如果要四舍五入，只有一种方法  
java.text.DecimalFormat：

import java.text.DecimalFormat;  
    public class NumberFormatMain {  
        public static void main(String args[]){  
            System.out.println(new DecimalFormat("0.00").format(4.025));  
            System.out.println(new DecimalFormat("0.00").format(4.024));  
        }  
    }

上边代码输出为：

public class FloatCounter {  
        public static void main(String args[]){  
            System.out.println(9969999999.04);  
            System.out.println(199999999.04);  
            System.out.println(1000000011.01);  
            System.out.println(9999999.04);  
        }  
    }

发现问题了么？因为DecimalFormat使用的舍入模式， 舍入模式 详情参见本文最后部分。  
\[3\] 浮点输出：  
　　Java浮点类型数值在大于9999999.0就自动转化成为科学计数法，看看下边的例子：

9.96999999904E9   
    1.9999999904E8   
    1.00000001101E9   
    9999999.04

输出结果为：  
但是有时候我们不需要科学计数法，而是转换成为字符串，所以这样可能会有点麻烦。  
总结：  
所以在项目当中，对于浮点类型以及大整数的运算 还是尽量不要用double，long等基本数据类型以及其包装类，还是用Java中提供的BigDecimal，BigInteger等大数值类型来代替吧。  
但这里特别说明一下BigDecimal类的两个构造函数的区别，他们分别是：  
new BigDecimal(String  val ) 和 new BigDecimal(double  val )  
先看例子：

public class BigDecimalMain {  
        public static void main(String args[]){  
            System.out.println(new BigDecimal(123456789.01).toString());  
            System.out.println(new BigDecimal("123456789.01").toString());  
        }  
    }

输出结果有一次令人意外了，同时两者之间的区别也一目了然了：

123456789.01000000536441802978515625   
    123456789.01

所以在 就是想利用double原始类型进行了相关计算之后再转成BigDecimal类型 的场合下，为了防止精度出现偏离，建议使用参数为String类型的该构造方法。即new BigDecimal(String  val )。

BigDecimal枚举常量用法摘要 ：

1.  CEILING：向正无限大方向舍入的舍入模式。
2.  FLOOR：  向负无限大方向舍入的舍入模式。
3.  UP：      远离零方向舍入的舍入模式。
4.  DOWN：向零方向舍入的舍入模式。
5.  HALF\_UP：      向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。
6.  HALF\_DOWN：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。
7.  HALF\_EVEN：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
8.  UNNECESSARY ：用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。

使用：new BigDecimal().setScale(newScale, BigDecimal.ROUND\_CEILING);

BigDecimal舍入模式介绍：  
舍入模式在java.math.RoundingMode 里面：  
RoundingMode.CEILING ：向正无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.UP；如果结果为负，则舍入行为类似于 RoundingMode.DOWN。注意，此舍入模式始终不会减少计算值

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用CEILING舍入模式将数字舍入为一位数&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>6&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2.5</td> 
   <td>3&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.1</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.0</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.0</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.1</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.6</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>-2</td> 
  </tr> 
  <tr> 
   <td>-5.5</td> 
   <td>-5</td> 
  </tr> 
 </tbody> 
</table>

RoundingMode.FLOOR ：向负无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.DOWN；如果结果为负，则舍入行为类似于 RoundingMode.UP。注意，此舍入模式始终不会增加计算值

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用FLOOR舍入模式将输入数字舍入为一位&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>5&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2.3</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.6</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.0</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.1</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>-3&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-5.5</td> 
   <td>-6</td> 
  </tr> 
 </tbody> 
</table>

RoundingMode.UP ：远离零方向舍入的舍入模式。始终对非零舍弃部分前面的数字加 1。注意，此舍入模式始终不会减少计算值的绝对值

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用UP舍入模式将输入数字舍入为一位数&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>6&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.6</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.1</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.0</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.1</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.6</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>-3&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-5.4</td> 
   <td>-6</td> 
  </tr> 
 </tbody> 
</table>

RoundingMode.DOWN ：向零方向舍入的舍入模式。从不对舍弃部分前面的数字加 1（即截尾）。注意，此舍入模式始终不会增加计算值的绝对值

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用DOWN舍入模式将数字舍入为一位数&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>5&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2.5</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.1</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.0</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.6</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-5.5</td> 
   <td>-5&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

RoundingMode.HALF\_UP ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。如果被舍弃部分 >= 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同 RoundingMode.DOWN。注意，此舍入模式就是通常学校里讲的四舍五入

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用HALF_UP舍入模式舍入为一位数&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>6&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2.5</td> 
   <td>3&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.6</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.0</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.1</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.6</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>-3&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-5.5</td> 
   <td>-6&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

RoundingMode.HALF\_DOWN ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。如果被舍弃部分 > 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同 RoundingMode.DOWN

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用HALF_DOWN输入模式舍入为一位&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>5&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2.5</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.6</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.0</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.1</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.6</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-5.5</td> 
   <td>-5&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

RoundingMode.HALF\_EVEN ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为同 RoundingMode.HALF\_UP；如果为偶数，则舍入行为同 RoundingMode.HALF\_DOWN。注意，在重复进行一系列计算时，此舍入模式可以在统计上将累加错误减到最小。此舍入模式也称为“银行家舍入法”，主要在美国使用。此舍入模式类似于 Java 中对 float 和 double 算法使用的舍入策略

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用HALF_EVEN舍入模式将输入舍为一位&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>6&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2.5</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.6</td> 
   <td>2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.1</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.0</td> 
   <td>-1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.6</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>-2&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-5.5</td> 
   <td>-6&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

RoundingMode.UNNECESSARY ：用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。如果对生成精确结果的操作指定此舍入模式，则抛出 ArithmeticException

<table> 
 <tbody> 
  <tr> 
   <td>输入数字</td> 
   <td>使用UNNECESSARY模式&nbsp;</td> 
  </tr> 
  <tr> 
   <td>5.5</td> 
   <td>抛出 ArithmeticException&nbsp;</td> 
  </tr> 
  <tr> 
   <td>2.5</td> 
   <td>抛出 ArithmeticException&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.6</td> 
   <td>抛出 ArithmeticException&nbsp;</td> 
  </tr> 
  <tr> 
   <td>1.0</td> 
   <td>1&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.0</td> 
   <td>-1.0&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.1</td> 
   <td>抛出 ArithmeticException&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-1.6</td> 
   <td>抛出 ArithmeticException&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-2.5</td> 
   <td>抛出 ArithmeticException&nbsp;</td> 
  </tr> 
  <tr> 
   <td>-5.5</td> 
   <td>抛出 ArithmeticException</td> 
  </tr> 
 </tbody> 
</table>

import  java.math.BigDecimal;   
    import  java.text.DecimalFormat;   
    /**  
     *使用舍入模式的格式化操作  
     **/   
    public class   DoubleFormat {   
        public static void  main(String  args[]){   
            DoubleFormat format =  new  DoubleFormat();   
            System.out .println(format.doubleOutPut(12.345, 2));   
            System.out .println(format.roundNumber(12.335, 2));   
        }   
        public   String  doubleOutPut(double  v,Integer num){   
            if ( v == Double.valueOf(v).intValue()){   
                return  Double.valueOf(v).intValue() +  "" ;   
            }else {   
                BigDecimal b =  new  BigDecimal(Double.toString(v));   
                return  b.setScale(num,BigDecimal.ROUND_HALF_UP ).toString();   
            }   
        }   
        public   String  roundNumber(double  v,int  num){   
            String  fmtString =  "0000000000000000" ;  //16bit   
            fmtString = num>0 ?  "0."   + fmtString.substring(0,num):"0" ;   
            DecimalFormat dFormat =  new  DecimalFormat(fmtString);   
            return  dFormat.format(v);   
        }   
    }

这段代码的输出为：

12.35   
    12.34

### 3.取最大值，最小值，绝对值，相反数 ###

1.  a.max (b) //比较取最大值
2.  a.min(b) //比较取最小值
3.  a.abs()//取最绝对值
4.  a.negate()//取相反数