Java BigDecimal的使用

Java BigDecimal的使用

Demo1

import java.math.BigDecimal;

/**
 * class：ava.math.BigDecimal
 * 使用场景：金额的计算
 */
public class TestDecimal {

    public static void main(String[] args) {
        testBigDecimalOpe();
        System.out.println("\n\r\n\r\");
        testBigDecimalDivRound();
    }

    public static void testBigDecimalOpe() {
        BigDecimal n1 = new BigDecimal(0.05);
        BigDecimal n2 = new BigDecimal(100);
        BigDecimal n3 = new BigDecimal(-100);
        //尽量用字符串的形式初始化
        BigDecimal s1 = new BigDecimal("0.05");
        BigDecimal s2 = new BigDecimal("100");
        BigDecimal s3 = new BigDecimal("-100");

        //加法
        BigDecimal addResult1 = n1.add(n2);
        BigDecimal addResult2 = s1.add(s2);

        System.out.println("value初始化后进行加法：" + addResult1);
        System.out.println("String初始化后进行加法：" + addResult2);
        System.out.println("=====================================");

        //减法
        BigDecimal subResult1 = n1.subtract(n2);
        BigDecimal subResult2 = s1.subtract(s2);

        System.out.println("value初始化后进行减法：" + subResult1);
        System.out.println("String初始化后进行减法：" + subResult2);
        System.out.println("=====================================");

        //乘法
        BigDecimal mulResult1 = n1.multiply(n2);
        BigDecimal mulResult2 = s1.multiply(s2);

        System.out.println("value初始化后进行乘法：" + mulResult1);
        System.out.println("String初始化后进行乘法：" + mulResult2);
        System.out.println("=====================================");

        //绝对值
        BigDecimal absResult1 = n3.abs();
        BigDecimal absResult2 = s3.abs();

        System.out.println("value初始化后进行取绝对值：" + absResult1);
        System.out.println("String初始化后进行取绝对值：" + absResult2);
        System.out.println("=====================================");

        //除法
        //注意：使用除法函数在divide的时候要设置各种参数，要精确的 小数位数 和 舍入模式 ，不然会出现报错
        //n2---分母   n1---分子     scale=10---精确小数位       int roundingMode 舍入模式
        BigDecimal divResult1 = n2.divide(n1, 10, BigDecimal.ROUND_HALF_UP);
        BigDecimal divResult2 = s2.divide(s1, 10, BigDecimal.ROUND_HALF_UP);

        System.out.println("value初始化后进行除法：" + divResult1);
        System.out.println("String初始化后进行除法：" + divResult2);
        System.out.println("=====================================");


    }


    public static void testBigDecimalDivRound() {
        BigDecimal n1 = new BigDecimal("1");
        BigDecimal n2 = new BigDecimal("3");

        //保留3位，最后一位+1
        BigDecimal r1 = n1.divide(n2, 3, BigDecimal.ROUND_UP);
        //保留3位，最后一位不会+1
        BigDecimal r2 = n1.divide(n2, 3, BigDecimal.ROUND_DOWN);
        //保留3位，向上+1---天花板
        BigDecimal r3 = n1.divide(n2, 3, BigDecimal.ROUND_CEILING);
        //保留3位，不会向上+1---地板
        BigDecimal r4 = n1.divide(n2, 3, BigDecimal.ROUND_FLOOR);
        //保留3位，舍弃部分 四舍五入
        BigDecimal r5 = n1.divide(n2, 3, BigDecimal.ROUND_HALF_UP);
        //保留3位，舍弃部分 五舍六入
        BigDecimal r6 = n1.divide(n2, 3, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal r7 = n1.divide(n2, 3, BigDecimal.ROUND_HALF_EVEN);

        System.out.println("1/3-ROUND_UP=" + r1);
        System.out.println("1/3-ROUND_DOWN=" + r2);
        System.out.println("1/3-ROUND_CEILING=" + r3);
        System.out.println("1/3-ROUND_FLOOR=" + r4);
        System.out.println("1/3-ROUND_HALF_UP=" + r5);
        System.out.println("1/3-ROUND_HALF_DOWN=" + r6);
        System.out.println("1/3-ROUND_HALF_EVEN=" + r7);
    }
   
}

输出：

value初始化后进行加法：100.05000000000000000277555756156289135105907917022705078125
String初始化后进行加法：100.05
=====================================
value初始化后进行减法：-99.94999999999999999722444243843710864894092082977294921875
String初始化后进行减法：-99.95
=====================================
value初始化后进行乘法：5.00000000000000027755575615628913510590791702270507812500
String初始化后进行乘法：5.00
=====================================
value初始化后进行取绝对值：100
String初始化后进行取绝对值：100
=====================================
value初始化后进行除法：2000.0000000000
String初始化后进行除法：2000.0000000000
=====================================

1/3-ROUND_UP=0.334
1/3-ROUND_DOWN=0.333
1/3-ROUND_CEILING=0.334
1/3-ROUND_FLOOR=0.333
1/3-ROUND_HALF_UP=0.333
1/3-ROUND_HALF_DOWN=0.333
1/3-ROUND_HALF_EVEN=0.333

Utils2

import com.google.common.base.Optional;

import java.math.BigDecimal;


/**
 * 数字计算的工具类
 *
 * 需要引入
 * <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
 * <dependency>
 *     <groupId>com.google.guava</groupId>
 *     <artifactId>guava</artifactId>
 *     <version>18.0</version>
 * </dependency>
 */
public class NumberArithmeticUtils {

    /**
     * BigDecimal的加法运算封装
     *
     * @param b1
     * @param bn
     * @return
     */
    public static BigDecimal safeAdd(BigDecimal b1, BigDecimal... bn) {

        if (null == b1) {
            b1 = BigDecimal.ZERO;
        }

        if (null != bn) {
            for (BigDecimal b : bn) {
                b1 = b1.add(null == b ? BigDecimal.ZERO : b);
            }
        }

        return b1;

    }


    /**
     * Integer加法运算的封装
     *
     * @param b1 第一个数
     * @param bn 需要加的加法数组
     * @return
     * @注 ： Optional  是属于com.google.common.base.Optional<T> 下面的class
     */

    public static Integer safeAdd(Integer b1, Integer... bn) {

        if (null == b1) {
            b1 = 0;
        }

        Integer r = b1;
        if (null != bn) {
            for (Integer b : bn) {
                r += Optional.fromNullable(b).or(0);
            }
        }

        return r > 0 ? r : 0;

    }


    /**
     * 计算金额方法
     *
     * @param b1
     * @param bn
     * @return
     */

    public static BigDecimal safeSubtract(BigDecimal b1, BigDecimal... bn) {

        return safeSubtract(true, b1, bn);

    }


    /**
     * BigDecimal的安全减法运算
     *
     * @param isZero 减法结果为负数时是否返回0，true是返回0（金额计算时使用），false是返回负数结果
     * @param b1     被减数
     * @param bn     需要减的减数数组
     * @return
     */

    public static BigDecimal safeSubtract(Boolean isZero, BigDecimal b1, BigDecimal... bn) {

        if (null == b1) {
            b1 = BigDecimal.ZERO;
        }

        BigDecimal r = b1;
        if (null != bn) {
            for (BigDecimal b : bn) {
                r = r.subtract((null == b ? BigDecimal.ZERO : b));
            }
        }

        return isZero ? (r.compareTo(BigDecimal.ZERO) == -1 ? BigDecimal.ZERO : r) : r;

    }


    /**
     * 整型的减法运算，小于0时返回0
     *
     * @param b1
     * @param bn
     * @return
     */

    public static Integer safeSubtract(Integer b1, Integer... bn) {

        if (null == b1) {
            b1 = 0;
        }

        Integer r = b1;
        if (null != bn) {
            for (Integer b : bn) {
                r -= Optional.fromNullable(b).or(0);
            }

        }

        return r > 0 ? r : 0;

    }


    /**
     * 金额除法计算，返回2位小数（具体的返回多少位大家自己看着改吧）
     *
     * @param b1
     * @param b2
     * @return
     */

    public static <T extends Number> BigDecimal safeDivide(T b1, T b2) {

        return safeDivide(b1, b2, BigDecimal.ZERO);

    }


    /**
     * BigDecimal的除法运算封装，如果除数或者被除数为0，返回默认值
     * <p>
     * 默认返回小数位后2位，用于金额计算
     *
     * @param b1
     * @param b2
     * @param defaultValue
     * @return
     */

    public static <T extends Number> BigDecimal safeDivide(T b1, T b2, BigDecimal defaultValue) {

        if (null == b1 || null == b2) {
            return defaultValue;
        }

        try {
            return BigDecimal.valueOf(b1.doubleValue()).divide(BigDecimal.valueOf(b2.doubleValue()), 2, BigDecimal.ROUND_HALF_UP);
        } catch (Exception e) {

            return defaultValue;

        }

    }


    /**
     * BigDecimal的乘法运算封装
     *
     * @param b1
     * @param b2
     * @return
     */

    public static <T extends Number> BigDecimal safeMultiply(T b1, T b2) {

        if (null == b1 || null == b2) {
            return BigDecimal.ZERO;
        }

        return BigDecimal.valueOf(b1.doubleValue()).multiply(BigDecimal.valueOf(b2.doubleValue())).setScale(2, BigDecimal.ROUND_HALF_UP);

    }
    
}