BigDecimal-精确表示货币值2

Java中BigDecimal的8种舍入模式

java.math.BigDecimal
不可变的、任意精度的有符号十进制数。BigDecimal 由任意精度的整数非标度值和32位的整数标度(scale)组成。
如果为零或正数，则标度是小数点后的位数。如果为负数，则将该数的非标度值乘以10的负scale次幂。
因此，BigDecimal表示的数值是(unscaledValue × 10-scale)。
与之相关的还有两个类：
java.math.MathContext：
该对象是封装上下文设置的不可变对象，它描述数字运算符的某些规则，如数据的精度，舍入方式等。
java.math.RoundingMode：
这是一种枚举类型，定义了很多常用的数据舍入方式。
这个类用起来还是很比较复杂的，原因在于舍入模式，数据运算规则太多太多，
不是数学专业出身的人看着中文API都难以理解，这些规则在实际中使用的时候在翻阅都来得及。
在银行、帐户、计费等领域，BigDecimal提供了精确的数值计算。其中8种舍入方式值得掌握。
1、ROUND_UP
舍入远离零的舍入模式。
在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1)。
注意，此舍入模式始终不会减少计算值的大小。
2、ROUND_DOWN
接近零的舍入模式。
在丢弃某部分之前始终不增加数字(从不对舍弃部分前面的数字加1，即截短)。
注意，此舍入模式始终不会增加计算值的大小。
3、ROUND_CEILING
接近正无穷大的舍入模式。
如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同;
如果为负，则舍入行为与 ROUND_DOWN 相同。
注意，此舍入模式始终不会减少计算值。
4、ROUND_FLOOR
接近负无穷大的舍入模式。
如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同;
如果为负，则舍入行为与 ROUND_UP 相同。
注意，此舍入模式始终不会增加计算值。
5、ROUND_HALF_UP
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同。
注意，这是我们大多数人在小学时就学过的舍入模式(四舍五入)。
6、ROUND_HALF_DOWN
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。
如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同(五舍六入)。
7、ROUND_HALF_EVEN
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同;
如果为偶数，则舍入行为与 ROUND_HALF_DOWN 相同。
注意，在重复进行一系列计算时，此舍入模式可以将累加错误减到最小。
此舍入模式也称为“银行家舍入法”，主要在美国使用。四舍六入，五分两种情况。
如果前一位为奇数，则入位，否则舍去。
以下例子为保留小数点1位，那么这种舍入方式下的结果。
1.15>1.2 1.25>1.2
8、ROUND_UNNECESSARY
断言请求的操作具有精确的结果，因此不需要舍入。
如果对获得精确结果的操作指定此舍入模式，则抛出ArithmeticException。

不同舍入模式下的舍入操作汇总

 根据给定的舍入模式将输入数字舍入为一位数的结果输入数字UPDOWNCEILINGFLOORHALF_UPHALF_DOWNHALF_EVENUNNECESSARY5.56565656抛出 ArithmeticException2.53232322抛出 ArithmeticException1.62121222抛出 ArithmeticException1.12121111抛出 ArithmeticException1.011111111-1.0-1-1-1-1-1-1-1-1-1.1-2-1-1-2-1-1-1抛出 ArithmeticException-1.6-2-1-1-2-2-2-2抛出 ArithmeticException-2.5-3-2-2-3-3-2-2抛出 ArithmeticException-5.5-6-5-5-6-6-5-6抛出 ArithmeticException

工具类：

package com.zpc.test;import java.math.BigDecimal;/** * 工具类，提供基于BigDecimal的加减乘除计算 */public class Arith {    /**     * 提供精确加法计算的add方法     *     * @param value1 被加数     * @param value2 加数     * @return 两个参数的和     */    public static double add(double value1, double value2) {        BigDecimal b1 = new BigDecimal(String.valueOf(value1));        BigDecimal b2 = new BigDecimal(String.valueOf(value2));        return b1.add(b2).doubleValue();    }    /**     * 提供精确减法运算的sub方法     *     * @param value1 被减数     * @param value2 减数     * @return 两个参数的差     */    public static double sub(double value1, double value2) {        BigDecimal b1 = new BigDecimal(String.valueOf(value1));        BigDecimal b2 = new BigDecimal(String.valueOf(value2));        return b1.subtract(b2).doubleValue();    }    /**     * 提供精确乘法运算的mul方法     *     * @param value1 被乘数     * @param value2 乘数     * @return 两个参数的积     */    public static double mul(double value1, double value2) {        BigDecimal b1 = new BigDecimal(String.valueOf(value1));        BigDecimal b2 = new BigDecimal(String.valueOf(value2));        return b1.multiply(b2).doubleValue();    }    /**     * @param value1       被除数     * @param value2       除数     * @param roundingMode 除不尽时采取的策略（小数的保留模式）     * @param scale        精确范围（小数点后的位数）     * @return 两个参数的商     * @throws IllegalAccessException roundingMode的取值：     *                                ROUND_UP 直接进位处理，如2.35变成2.4     *                                ROUND_DOWN 直接删除多余的小数位，如2.35会变成2.3     *                                ROUND_CEILING 接近正无穷大的舍入模式.如果 BigDecimal为正，则舍入行为与 ROUND_UP相同; 如果为负，则舍入行为与 ROUND_DOWN 相同     *                                ROUND_FLOOR   接近负无穷大的舍入模式.如果 BigDecimal为正，则舍入行为与ROUND_DOWN相同;如果为负，则舍入行为与 ROUND_UP 相同     *                                ROUND_HALF_UP 四舍五入，如2.35变成2.4，5向上进     *                                ROUND_HALF_DOWN 四舍五入，2.35变成2.3，5向下舍     *                                ROUND_HALF_EVEN 如果舍弃部分左边的数字为奇数,则作 ROUND_HALF_UP;如果它为偶数,则作ROUND_HALF_DOWN     *                                ROUND_UNNECESSARY "伪舍入模式"实际是指明所要求的操作必须是精确的,因此不需要舍入操作     */    public static double div(double value1, double value2, int roundingMode, int scale) throws IllegalAccessException {        //如果精确范围小于0，抛出异常信息        if (scale < 0) {            throw new IllegalAccessException("精确度不能小于0");        }        if (roundingMode < BigDecimal.ROUND_UP || roundingMode > BigDecimal.ROUND_UNNECESSARY)            throw new IllegalArgumentException("Invalid rounding mode");        BigDecimal b1 = new BigDecimal(String.valueOf(value1));        BigDecimal b2 = new BigDecimal(String.valueOf(value2));        return b1.divide(b2, scale, roundingMode).doubleValue();    }    /**     * 提供精确的除法运算方法div     * 默认保留两位小数     *     * @param value1       被除数     * @param value2       除数     * @param roundingMode 除不尽时采取的策略（小数的保留模式）     * @return 两个参数的商     * @throws IllegalAccessException     */    public static double div(double value1, double value2, int roundingMode) throws IllegalAccessException {        return div(value1, value2, roundingMode, 2);    }    /**     * 默认使用四舍五入,保留两位小数     *     * @param value1     * @param value2     * @return     * @throws IllegalAccessException     */    public static double div(double value1, double value2) throws IllegalAccessException {        return div(value1, value2, BigDecimal.ROUND_HALF_UP);    }}

测试类：

package com.zpc.test;import java.math.BigDecimal;public class TestBigDecimal{    public static void main(String[] args) throws IllegalAccessException {        System.out.println(0.06 + 0.01);        System.out.println(Arith.add(0.06, 0.01));        System.out.println(1.0 - 0.55);        System.out.println(Arith.sub(1.0, 0.55));        System.out.println(4.213 * 1000);        System.out.println(Arith.mul(4.213, 1000));        System.out.println("===================================================");        System.out.println(123.49 / 100);        System.out.println(Arith.div(123.591, 100, 4));//四舍五入,默认保留两位小数        System.out.println(Arith.div(123.491, 100, 4));        System.out.println(Arith.div(124.491, 100, 4,1));//四舍五入,保留1位小数        System.out.println(Arith.div(125.451, 100, 4,3));//四舍五入,保留3位小数        System.out.println(Arith.div(125.441, 100, 4,3));                                System.out.println("===================================================");        BigDecimal bigDecimal1 = new BigDecimal(1.33);        BigDecimal bigDecimal2 = new BigDecimal("1.33");        System.out.println(bigDecimal1.add(new BigDecimal(2.44)));        System.out.println(bigDecimal2.add(new BigDecimal(2.44)));        System.out.println(bigDecimal2.add(new BigDecimal("2.44")));//要得到精确值推荐使用String参数类型的构造器        System.out.println("===================================================");        BigDecimal mData1 = new BigDecimal("9.6554").setScale(3, BigDecimal.ROUND_HALF_UP);        BigDecimal mData2 = new BigDecimal("9.6555").setScale(3, BigDecimal.ROUND_HALF_UP);        System.out.println(mData1);        System.out.println(mData2);        System.out.println("===================================================");        BigDecimal mData3 = new BigDecimal("9.6554").setScale(3, BigDecimal.ROUND_DOWN);        BigDecimal mData4 = new BigDecimal("9.65589").setScale(3, BigDecimal.ROUND_DOWN);        System.out.println(mData3);        System.out.println(mData4);        System.out.println("===================================================");        BigDecimal mData5 = new BigDecimal("9.6554").setScale(3, BigDecimal.ROUND_HALF_DOWN);        BigDecimal mData6 = new BigDecimal("9.6555").setScale(3, BigDecimal.ROUND_HALF_DOWN);        BigDecimal mData7 = new BigDecimal("9.6556").setScale(3, BigDecimal.ROUND_HALF_DOWN);        System.out.println(mData5);        System.out.println(mData6);        System.out.println(mData7);    }}