BigDecimal的使用

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

一、构造方法

BigDecimal一共有4个够造方法:

　　BigDecimal(int) 创建一个具有参数所指定整数值的对象。

　　BigDecimal(double) 创建一个具有参数所指定双精度值的对象。

　　BigDecimal(long) 创建一个具有参数所指定长整数值的对象。

BigDecimal(String)创建一个具有参数所指定以字符串表示的数值的对象。

它的构造函数很多，我挑最常用的两个来演示一下：一个就是BigDecimal (doubleval)，另一个就是BigDecimal(String str)。这两个看上去没什么太大区别，但是正像API描述中说的那样，就不描述了。意思就是说利用double作为参数的构造函数，无法精确构造一个BigDecimal对象，需要自己指定一个上下文的环境，也就是指定精确位。而利用String对象作为参数传入的构造函数能精确的构造出一个BigDecimal对象。请看下面的代码：

import java.math.*;  
public class TestBigDecimal {  
    public static void main(String args[]){  
        BigDecimal bd = new BigDecimal("10.123");  
        BigDecimal bd1 = new BigDecimal(10.123);  
        System.out.println(bd +"/n"+ bd1);  
    }  
}  

输出：

10.123
10.1229999999999993320898283855058252811431884765625

所以我们在选择构造函数时，要看具体需求而定。

另外，很多人会问到怎么将基本类型，如int，float，double，long，和BigDecimal对象相互转换。很简单：

基本类型通过构造函数转换成对应的BigDecimal对象，而BigDecimal类提供了诸如intValue(), floatValue(), doubleValue(), longValue()方法来将BigDecimal对象转换成对应的值。

关于BigDecimal是如何计算的，我以论坛中一个人的提问帖子为例，来简单的写出BigDecimal的运算方法。题目是：李白无事街上走，提壶去买酒。遇店加一倍，见花喝一斗，五遇花和店，喝光壶中酒，试问李白壶中原有多少斗酒？

这道题应该是从后往前推，并且要逆运算，最后得出原有酒的体积。

import java.math.*;  
public class Libai {  
    public static void main(String args[]){  
        BigDecimal volumn = new BigDecimal("0");  
        for (int i=0; i<5;  i++){             
            volumn = volumn.add(new BigDecimal("1"));  
            volumn = volumn.divide(new BigDecimal("2"));  
        }  
        System.out.print(volumn);  
    }  
}  

结果： 0.96875

BigDecimal的标度：

构造方法：

方法：

下面是关于此类的用法：

// 默认运算精度  
    private static int DEF_SCALE = 10;  
  
    /** 
     * 提供数据类型转换为BigDecimal 
     *  
     * @param object 
     *            原始数据 
     * @return BigDecimal 
     */  
    public static BigDecimal bigDecimal(Object object) {  
        if (object == null) {  
            throw new NullPointerException();  
        }  
        BigDecimal result;  
        try {  
            result = new BigDecimal(String.valueOf(object).replaceAll(",", ""));  
        } catch (NumberFormatException e) {  
            throw new NumberFormatException("Please give me a numeral.Not " + object);  
        }  
        return result;  
    }  
  
    /** 
     * 提供(相对)精确的加法运算。 
     *  
     * @param num1 
     *            被加数 
     * @param num2 
     *            加数 
     * @return 两个参数的和 
     */  
    public static Double add(Object num1, Object num2) {  
        BigDecimal result = bigDecimal(num1).add(bigDecimal(num2));  
        return result.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /** 
     * 提供(相对)精确的减法运算。 
     *  
     * @param num1 
     *            被减数 
     * @param num2 
     *            减数 
     * @return 两个参数的差 
     */  
    public static Double subtract(Object num1, Object num2) {  
        BigDecimal result = bigDecimal(num1).subtract(bigDecimal(num2));  
        return result.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /** 
     * 提供(相对)精确的乘法运算。 
     *  
     * @param num1 
     *            被乘数 
     * @param num2 
     *            乘数 
     * @return 两个参数的积 
     */  
    public static Double multiply(Object num1, Object num2) {  
        BigDecimal result = bigDecimal(num1).multiply(bigDecimal(num2));  
        return result.setScale(DEF_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /** 
     * 提供(相对)精确的除法运算，当发生除不尽的情况时，精度为10位，以后的数字四舍五入。 
     *  
     * @param num1 
     *            被除数 
     * @param num2 
     *            除数 
     * @return 两个参数的商 
     */  
    public static Double divide(Object num1, Object num2) {  
        return divide(num1, num2, DEF_SCALE);  
    }  
  
    /** 
     * 提供(相对)精确的除法运算。 当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。 
     *  
     * @param num1 
     *            被除数 
     * @param num2 
     *            除数 
     * @param scale 
     *            表示表示需要精确到小数点以后几位。 
     * @return 两个参数的商 
     */  
    public static Double divide(Object num1, Object num2, Integer scale) {  
        if (scale == null) {  
            scale = DEF_SCALE;  
        }  
        num2 = num2 == null || Math.abs(new Double(num2.toString())) == 0 ? 1 : num2;  
        if (scale < 0) {  
            throw new IllegalArgumentException("The scale must be a positive integer or zero");  
        }  
        BigDecimal result = bigDecimal(num1).divide(bigDecimal(num2), scale,  
            BigDecimal.ROUND_HALF_UP);  
        return result.doubleValue();  
    }  
  
    /** 
     * 提供精确的小数位四舍五入处理。 
     *  
     * @param num 
     *            需要四舍五入的数字 
     * @param scale 
     *            小数点后保留几位 
     * @return 四舍五入后的结果 
     */  
    public static Double round(Object num, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException("The scale must be a positive integer or zero");  
        }  
        BigDecimal result = bigDecimal(num)  
            .divide(bigDecimal("1"), scale, BigDecimal.ROUND_HALF_UP);  
        return result.doubleValue();  
    }  
  
    /** 
     * 获取start到end区间的随机数,不包含start+end 
     *  
     * @param start 
     * @param end 
     * @return 
     */  
    public static BigDecimal getRandom(int start, int end) {  
        return new BigDecimal(start + Math.random() * end);  
    }  
  
    /** 
     * 格式化 
     * @param obj 
     * @param pattern 
     * @return 
     */  
    public static String format(Object obj, String pattern) {  
        if (obj == null) {  
            return null;  
        }  
        if (pattern == null || "".equals(pattern)) {  
            pattern = "#";  
        }  
        DecimalFormat format = new DecimalFormat(pattern);  
        return format.format(bigDecimal(obj));  
    }