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。

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

  根据给定的舍入模式将输入数字舍入为一位数的结果 输入数字 UP DOWN CEILING FLOOR HALF_UP HALF_DOWN HALF_EVEN UNNECESSARY 5.5 6 5 6 5 6 5 6 抛出  ArithmeticException 2.5 3 2 3 2 3 2 2 抛出  ArithmeticException 1.6 2 1 2 1 2 2 2 抛出  ArithmeticException 1.1 2 1 2 1 1 1 1 抛出  ArithmeticException 1.0 1 1 1 1 1 1 1 1 -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);
    }
}