BigDecimal

最新推荐文章于 2023-10-13 17:47:42 发布

IT_老王

最新推荐文章于 2023-10-13 17:47:42 发布

阅读量154

点赞数

分类专栏：学习

本文链接：https://blog.csdn.net/weixin_42871989/article/details/108289989

版权

学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

1. BigDecimal概述
2. BigDecimal常用API

1. BigDecimal概述

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。
BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

2. BigDecimal常用API

源码:

链接：https://pan.baidu.com/s/1CzeBv4zTGjOAElx84eMlCA 
提取码：e5tk

2.1 add() 加法

public static void main(String[] args) {
        /** add()  加法,BigDecimal对象中的值相加，返回BigDecimal对象
         *  BigDecimal add(BigDecimal augend)
         *  augend : 加数
         */
        BigDecimal decimal1 = new BigDecimal("1.2");
        BigDecimal decimal2 = new BigDecimal("1.9");
        BigDecimal result = decimal1.add(decimal2);
        System.out.println("结果: " + result); //结果: 3.1
}

2.2 subtract() 减法

public static void main(String[] args) {
        /**
         * subtract() 减法,BigDecimal对象中的值相减，返回BigDecimal对象
         * BigDecimal subtract(BigDecimal subtrahend)
         * subtrahend : 减数
         */
        BigDecimal decimal1 = new BigDecimal("1.9");
        BigDecimal decimal2 = new BigDecimal("1.2");
        BigDecimal result = decimal1.subtract(decimal2);
        System.out.println("结果: " + result);  //结果: 0.7
}

2.3 multiply() 乘法

public static void main(String[] args) {
        /**
         * multiply() 乘法,BigDecimal对象中的值相乘，返回BigDecimal对象
         * BigDecimal multiply(BigDecimal multiplicand)
         * multiplicand : 乘数
         */
        BigDecimal decimal1 = new BigDecimal("1.9");
        BigDecimal decimal2 = new BigDecimal("1.2");
        BigDecimal result = decimal1.multiply(decimal2);
        System.out.println("结果: " + result);  //结果: 2.28
}

2.4 divide() 除法

如果除不尽,会抛出异常: java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result
解决办法 : 精确的小数位数和舍入模式

public static void main(String[] args) {
        /**
         * divide() 除法,BigDecimal对象中的值相除，返回BigDecimal对象
         * BigDecimal divide(BigDecimal divisor)
         * divisor : 除数
         * 如果除不尽,会抛出异常: java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result
         * 解决办法 : 精确的小数位数和舍入模式
         */
        BigDecimal decimal1 = new BigDecimal("4");
        BigDecimal decimal2 = new BigDecimal("2");
        BigDecimal result = decimal1.divide(decimal2);
        System.out.println("结果: " + result);  //结果: 2

        BigDecimal decimal3 = new BigDecimal("1");
        BigDecimal decimal4 = new BigDecimal("3");
        /**
         * 解决办法
         * BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
         * divisor : 除数
         * scale : 精确小数位
         * roundingMode : 舍入模式
         */
        BigDecimal result1 = decimal3.divide(decimal4,2,BigDecimal.ROUND_HALF_UP);
        System.out.println("结果: " + result1);  //结果: 0.33
}

2.5 BigDecimal八大舍入模式

2.5.1 BigDecimal.ROUND_UP(或者RoundingMode.UP) : 在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1,正数,负数都是加1)

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_UP(或者RoundingMode.UP) : 在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1,正数,负数都是加1)
         *                       只要舍弃的部分有数字,并且都不为零,舍去之后都对前面的数字加1
         *  注意: 正数舍入后,计算值始终不会减小;  负数舍入后,计算值始终不会增大
         * BigDecimal setScale(int newScale, int roundingMode)
         * newScale : 保留的小数点位数
         * roundingMode : 舍入模式
         */
        BigDecimal a1 = new BigDecimal("1.2309").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a2 = new BigDecimal("1.231").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a3 = new BigDecimal("1.234").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a4 = new BigDecimal("1.235").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a5 = new BigDecimal("1.239").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a6 = new BigDecimal("-1.231").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a7 = new BigDecimal("-1.234").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a8 = new BigDecimal("-1.235").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a9 = new BigDecimal("-1.239").setScale(2, BigDecimal.ROUND_UP);
        System.out.println("a1: " + a1);  //a1: 1.24
        System.out.println("a2: " + a2);  //a2: 1.24
        System.out.println("a3: " + a3);  //a3: 1.24
        System.out.println("a4: " + a4);  //a4: 1.24
        System.out.println("a5: " + a5);  //a5: 1.24
        System.out.println("a6: " + a6);  //a6: -1.24
        System.out.println("a7: " + a7);  //a7: -1.24
        System.out.println("a8: " + a8);  //a8: -1.24
        System.out.println("a9: " + a9);  //a9: -1.24
}

2.5.2 BigDecimal.ROUND_DOWN(或者RoundingMode.DOWN) : 正数: 直接舍去后面的位数,负数: 只要舍弃的部分有数字,并且都不为零,舍去之后都对前面的数字加1

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_DOWN(或者RoundingMode.DOWN) : 正数: 直接舍去后面的位数
         *                         负数: 只要舍弃的部分有数字,并且都不为零,舍去之后都对前面的数字加1
         *  注意: 舍入后,计算值始终不会增大
         */
        BigDecimal a1 = new BigDecimal("1.2309").setScale(2, BigDecimal.ROUND_DOWN);
        BigDecimal a2 = new BigDecimal("1.231").setScale(2, BigDecimal.ROUND_DOWN);
        BigDecimal a3 = new BigDecimal("1.234").setScale(2, BigDecimal.ROUND_DOWN);
        BigDecimal a4 = new BigDecimal("1.235").setScale(2, BigDecimal.ROUND_DOWN);
        BigDecimal a5 = new BigDecimal("1.239").setScale(2, BigDecimal.ROUND_DOWN);
        BigDecimal a6 = new BigDecimal("-1.231").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a7 = new BigDecimal("-1.234").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a8 = new BigDecimal("-1.235").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a9 = new BigDecimal("-1.239").setScale(2, BigDecimal.ROUND_UP);
        BigDecimal a10 = new BigDecimal("-1.2309").setScale(2, BigDecimal.ROUND_UP);
        System.out.println("a1: " + a1);    //a1: 1.23
        System.out.println("a2: " + a2);    //a2: 1.23
        System.out.println("a3: " + a3);    //a3: 1.23
        System.out.println("a4: " + a4);    //a4: 1.23
        System.out.println("a5: " + a5);    //a5: 1.23
        System.out.println("a6: " + a6);    //a6: -1.24
        System.out.println("a7: " + a7);    //a7: -1.24
        System.out.println("a8: " + a8);    //a8: -1.24
        System.out.println("a9: " + a9);    //a9: -1.24
        System.out.println("a10: " + a10);  //a10: -1.24
}

2.5.3 BigDecimal.ROUND_CEILING(或者RoundingMode.CEILING) : 正数: 只要舍弃的部分有数字,并且都不为零,舍去之后都对前面的数字加1,负数: 直接舍去后面的位数

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_CEILING(或者RoundingMode.CEILING) : 正数: 只要舍弃的部分有数字,并且都不为零,舍去之后都对前面的数字加1
         *                            负数: 直接舍去后面的位数
         *  注意: 舍入后,计算值始终不会减小
         */
        BigDecimal a1 = new BigDecimal("1.2309").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a2 = new BigDecimal("1.231").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a3 = new BigDecimal("1.234").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a4 = new BigDecimal("1.235").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a5 = new BigDecimal("1.239").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a6 = new BigDecimal("-1.231").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a7 = new BigDecimal("-1.234").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a8 = new BigDecimal("-1.235").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a9 = new BigDecimal("-1.239").setScale(2, BigDecimal.ROUND_CEILING);
        BigDecimal a10 = new BigDecimal("-1.2309").setScale(2, BigDecimal.ROUND_CEILING);
        System.out.println("a1: " + a1);    //a1: 1.24
        System.out.println("a2: " + a2);    //a2: 1.24
        System.out.println("a3: " + a3);    //a3: 1.24
        System.out.println("a4: " + a4);    //a4: 1.24
        System.out.println("a5: " + a5);    //a5: 1.24
        System.out.println("a6: " + a6);    //a6: -1.23
        System.out.println("a7: " + a7);    //a7: -1.23
        System.out.println("a8: " + a8);    //a8: -1.23
        System.out.println("a9: " + a9);    //a9: -1.23
        System.out.println("a10: " + a10);  //a10: -1.23
}

2.5.4 BigDecimal.ROUND_FLOOR(RoundingMode.FLOOR) : 向下取值,正数: 直接舍去后面的值,负数: 只要舍弃的部分有数字,并且都不为零,舍去之后都对前面的数字加1

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_FLOOR(RoundingMode.FLOOR) : 向下取值
         *                          正数: 直接舍去后面的值
         *                          负数: 只要舍弃的部分有数字,并且都不为零,舍去之后都对前面的数字加1
         * 注意: 舍入后,计算值始终不会增大
         */
        BigDecimal a1 = new BigDecimal("1.2309").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a2 = new BigDecimal("1.231").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a3 = new BigDecimal("1.234").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a4 = new BigDecimal("1.235").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a5 = new BigDecimal("1.239").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a6 = new BigDecimal("-1.231").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a7 = new BigDecimal("-1.234").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a8 = new BigDecimal("-1.235").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a9 = new BigDecimal("-1.239").setScale(2, BigDecimal.ROUND_FLOOR);
        BigDecimal a10 = new BigDecimal("-1.2309").setScale(2, BigDecimal.ROUND_FLOOR);
        System.out.println("a1: " + a1);    //a1: 1.23
        System.out.println("a2: " + a2);    //a2: 1.23
        System.out.println("a3: " + a3);    //a3: 1.23
        System.out.println("a4: " + a4);    //a4: 1.23
        System.out.println("a5: " + a5);    //a5: 1.23
        System.out.println("a6: " + a6);    //a6: -1.24
        System.out.println("a7: " + a7);    //a7: -1.24
        System.out.println("a8: " + a8);    //a8: -1.24
        System.out.println("a9: " + a9);    //a9: -1.24
        System.out.println("a10: " + a10);  //a10: -1.24
}

2.5.5 BigDecimal.ROUND_HALF_UP(RoundingMode.HALF_UP) : 四舍五入(正负一样)

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_HALF_UP(RoundingMode.HALF_UP) : 四舍五入(正负一样)
         */
        BigDecimal a1 = new BigDecimal("1.2309").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a2 = new BigDecimal("1.231").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a3 = new BigDecimal("1.234").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a4 = new BigDecimal("1.235").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a5 = new BigDecimal("1.239").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a6 = new BigDecimal("-1.231").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a7 = new BigDecimal("-1.234").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a8 = new BigDecimal("-1.235").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a9 = new BigDecimal("-1.239").setScale(2, BigDecimal.ROUND_HALF_UP);
        BigDecimal a10 = new BigDecimal("-1.2309").setScale(2, BigDecimal.ROUND_HALF_UP);
        System.out.println("a1: " + a1);    //a1: 1.23
        System.out.println("a2: " + a2);    //a2: 1.23
        System.out.println("a3: " + a3);    //a3: 1.23
        System.out.println("a4: " + a4);    //a4: 1.24
        System.out.println("a5: " + a5);    //a5: 1.24
        System.out.println("a6: " + a6);    //a6: -1.23
        System.out.println("a7: " + a7);    //a7: -1.23
        System.out.println("a8: " + a8);    //a8: -1.24
        System.out.println("a9: " + a9);    //a9: -1.24
        System.out.println("a10: " + a10);  //a10: -1.23
}

2.5.6 BigDecimal.ROUND_HALF_DOWN(RoundingMode.HALF_DOWN) : 五舍六入(正负一样)

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_HALF_DOWN(RoundingMode.HALF_DOWN) : 五舍六入(正负一样)
         */
        BigDecimal a1 = new BigDecimal("1.2309").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a2 = new BigDecimal("1.231").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a3 = new BigDecimal("1.234").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a4 = new BigDecimal("1.235").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a5 = new BigDecimal("1.236").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a6 = new BigDecimal("-1.231").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a7 = new BigDecimal("-1.234").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a8 = new BigDecimal("-1.235").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a9 = new BigDecimal("-1.236").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        BigDecimal a10 = new BigDecimal("-1.2309").setScale(2, BigDecimal.ROUND_HALF_DOWN);
        System.out.println("a1: " + a1);    //a1: 1.23
        System.out.println("a2: " + a2);    //a2: 1.23
        System.out.println("a3: " + a3);    //a3: 1.23
        System.out.println("a4: " + a4);    //a4: 1.23
        System.out.println("a5: " + a5);    //a5: 1.24
        System.out.println("a6: " + a6);    //a6: -1.23
        System.out.println("a7: " + a7);    //a7: -1.23
        System.out.println("a8: " + a8);    //a8: -1.23
        System.out.println("a9: " + a9);    //a9: -1.24
        System.out.println("a10: " + a10);  //a10: -1.23
}

2.5.7 BigDecimal.ROUND_HALF_EVEN(RoundingMode.HALF_EVEN) : 四舍六入,五分(正负数一样),又称银行家舍入法(主要用在美国)

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_HALF_EVEN(RoundingMode.HALF_EVEN) : 四舍六入,五分(正负数一样),又称银行家舍入法(主要用在美国)
         *                              五分有以下两种情况:
         *                                     ①如果前一位为奇数，则入位
         *                                     ②如果前一位为偶数，则舍去
         */
        BigDecimal a1 = new BigDecimal("1.231").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a2 = new BigDecimal("1.234").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a3 = new BigDecimal("1.235").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a4 = new BigDecimal("1.225").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a5 = new BigDecimal("1.236").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a6 = new BigDecimal("1.239").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("a1: " + a1);    //a1: 1.23
        System.out.println("a2: " + a2);    //a2: 1.23
        System.out.println("a3: " + a3);    //a3: 1.24
        System.out.println("a4: " + a4);    //a4: 1.22
        System.out.println("a5: " + a5);    //a5: 1.24
        System.out.println("a6: " + a6);    //a6: 1.24
        System.out.println("=================================================================================");
        BigDecimal a7 = new BigDecimal("-1.231").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a8 = new BigDecimal("-1.234").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a9 = new BigDecimal("-1.235").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a10 = new BigDecimal("-1.225").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a11 = new BigDecimal("-1.236").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        BigDecimal a12 = new BigDecimal("-1.239").setScale(2, BigDecimal.ROUND_HALF_EVEN);
        System.out.println("a7: " + a7);       //a7: -1.23
        System.out.println("a8: " + a8);       //a8: -1.23
        System.out.println("a9: " + a9);       //a9: -1.24
        System.out.println("a10: " + a10);     //a10: -1.22
        System.out.println("a11: " + a11);     //a11: -1.24
        System.out.println("a12: " + a12);     //a12: -1.24
}

2.5.8 BigDecimal.ROUND_UNNECESSARY(或者RoundingMode.UNNECESSARY) 计算结果是精确的，不需要舍入模式

public static void main(String[] args) {
        /**
         * BigDecimal.ROUND_UNNECESSARY(或者RoundingMode.UNNECESSARY) 计算结果是精确的，不需要舍入模式
         */
        //会抛出异常
        BigDecimal a1 = new BigDecimal("1.2309").setScale(2, BigDecimal.ROUND_UNNECESSARY);
        //不会抛出异常
        BigDecimal a2 = new BigDecimal("1.231").setScale( BigDecimal.ROUND_UNNECESSARY);

        System.out.println("a1 " + a1);    //
        System.out.println("a2: " + a2);    //a2: 1.2310000
}

2.6 abs() 绝对值

public static void main(String[] args) {
        /**
         * abs() 绝对值
         * BigDecimal abs()
         */
        BigDecimal a1 = new BigDecimal("1");
        BigDecimal a2 = new BigDecimal("3");
        BigDecimal abs = a1.subtract(a2).abs();
        System.out.println(abs);  //2
}

2.7 remainder() 求余数

public static void main(String[] args) {
        /**
         * remainder()  求余数
         * BigDecimal remainder(BigDecimal divisor)
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal a2 = new BigDecimal("3");
        BigDecimal result = a1.remainder(a2);
        System.out.println(result);  //2
}

2.8 divideAndRemainder() 求商和余数

public static void main(String[] args) {
        /**
         * divideAndRemainder() 求商和余数
         * BigDecimal[] divideAndRemainder(BigDecimal divisor)
         * BigDecimal[0] : 商
         * BigDecimal[1]  : 余数
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal a2 = new BigDecimal("3");
        BigDecimal[] result = a1.divideAndRemainder(a2);
        BigDecimal b1 = result[0];   //商
        BigDecimal b2 = result[1];  //余数
        System.out.println(b1);  //1
        System.out.println(b2);  //2
}

2.9 max() 求最大数

public static void main(String[] args) {
        /**
         * max() 求最大数
         * BigDecimal max(BigDecimal val)
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal a2 = new BigDecimal("3");
        BigDecimal result = a1.max(a2);
        System.out.println(result);  //5
}

2.10 min() 求最小数

public static void main(String[] args) {
        /**
         * min() 求最小数
         * BigDecimal min(BigDecimal val)
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal a2 = new BigDecimal("3");
        BigDecimal result = a1.min(a2);
        System.out.println(result);  //3
}

2.11 negate() 求相反数

public static void main(String[] args) {
        /**
         * negate() 求相反数
         * BigDecimal negate()
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal a2 = new BigDecimal("3");
        BigDecimal result = a1.subtract(a2).negate();
        System.out.println(result);  //-2
}

2.12 compareTo() 比较大小

public static void main(String[] args) {
        /**
         * compareTo() 比较大小
         * 返回值为1 : 前数大于后数
         * 返回值为0 : 前数等于后数
         * 返回值为-1 : 前数小于后数
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal a2 = new BigDecimal("3");
        int result = a1.compareTo(a2);
        System.out.println(result);  //1
}

2.13 divideToIntegralValue() 四舍五入商的整数部分

public static void main(String[] args) {
        /**
         * divideToIntegralValue() 四舍五入商的整数部分
         * BigDecimal divideToIntegralValue(BigDecimal divisor)
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal a2 = new BigDecimal("3");
        BigDecimal result = a1.divideToIntegralValue(a2);
        System.out.println(result);  //1
}

2.14 doubleValue() 将BigDecimal类型准换成double类型

public static void main(String[] args) {
        /**
         * doubleValue() 将BigDecimal类型准换成double类型
         * double doubleValue()
         */
        BigDecimal a1 = new BigDecimal("5");
        double result = a1.doubleValue();
        System.out.println(result);  //5.0
}

2.15 floatValue() 将BigDecimal类型准换成float类型

public static void main(String[] args) {
        /**
         * floatValue() 将BigDecimal类型准换成float类型
         * float floatValue()
         */
        BigDecimal a1 = new BigDecimal("5");
        float result = a1.floatValue();
        System.out.println(result);  //5.0
}

2.16 intValue() 将BigDecimal类型准换成int类型

public static void main(String[] args) {
        /**
         * intValue() 将BigDecimal类型准换成int类型
         * int intValue()
         */
        BigDecimal a1 = new BigDecimal("5");
        int result = a1.intValue();
        System.out.println(result);  //5
}

2.17 longValue() 将BigDecimal类型准换成long类型

public static void main(String[] args) {
        /**
         * longValue() 将BigDecimal类型准换成long类型
         * long longValue()
         */
        BigDecimal a1 = new BigDecimal("5");
        long result = a1.longValue();
        System.out.println(result);  //5
}

2.18 pow() : 求一个数额次方数,（this^n）,精确计算幂次，且精度不受限制

public static void main(String[] args) {
        /**
         * pow() : 求一个数额次方数,（this^n）,精确计算幂次，且精度不受限制
         * BigDecimal pow(int n)
         * n : 为次方数,只能为正数
         */
        BigDecimal a1 = new BigDecimal("5");
        BigDecimal result = a1.pow(2);
        System.out.println(result);   //25
}

2.19 stripTrailingZeros() 删除数字末尾所有无用的零

public static void main(String[] args) {
        /**
         * stripTrailingZeros() 删除数字末尾所有无用的零
         * BigDecimal stripTrailingZeros()
         */
        BigDecimal a1 = new BigDecimal("5.0");
        BigDecimal a2 = new BigDecimal("3.2500");
        BigDecimal result1 = a1.stripTrailingZeros();
        BigDecimal result2 = a2.stripTrailingZeros();
        System.out.println(result1);  //5
        System.out.println(result2);  //3.25
}

2.20 toBigInteger() 将BigDecimal转换成BigInteger

public static void main(String[] args) {
        /**
         * toBigInteger() 将BigDecimal转换成BigInteger
         * BigInteger toBigInteger()
         */
        BigDecimal a1 = new BigDecimal("5.02");
        BigDecimal a2 = new BigDecimal("5.92");
        BigInteger result = a1.toBigInteger();
        BigInteger result2 = a2.toBigInteger();
        System.out.println(result);  //5
        System.out.println(result2);  //5
}

2.21 toPlainString() 返回BigDecimal 不带指数字段的字符串表示形式,防止输出科学计数法的数字

public static void main(String[] args) {
        /**
         * toPlainString() 返回BigDecimal 不带指数字段的字符串表示形式,防止输出科学计数法的数字
         * String toPlainString()
         */
        BigDecimal a1 = new BigDecimal("0.000000001");
        String result1 = a1.toString();
        String result2 = a1.toPlainString();
        System.out.println(result1);  //1E-9
        System.out.println(result2);  //0.000000001
}

2.22 valueOf() 将double/long类型转换成BigDecimal

public static void main(String[] args) {
        /**
         * valueOf() 将double/long类型转换成BigDecimal
         * BigDecimal valueOf(long val)
         * BigDecimal valueOf(double val)
         */
        BigDecimal result1 = BigDecimal.valueOf(2L);
        BigDecimal result2 = BigDecimal.valueOf(2d);
        System.out.println(result1);  //2
        System.out.println(result2);  //2.0
}

2.23 格式化

public static void main(String[] args) {
        /**
         * 格式化
         */
        //建立货币格式化引用 ￥
//        NumberFormat currency = NumberFormat.getCurrencyInstance();
//        BigDecimal a1 = new BigDecimal("50.12");
//        String format = currency.format(a1);
//        System.out.println(format);   //￥50.12

        //建立百分比格式化引用
//        NumberFormat percent = NumberFormat.getPercentInstance();
        //百分比小数点最多3位
//        percent.setMaximumFractionDigits(3);
//        BigDecimal a1 = new BigDecimal("0.1230867");
//        String format = percent.format(a1);
//        System.out.println(format);   //12.309%


        /**
         * #表示没有则为空，0表示如果没有则补0
         */
//        DecimalFormat df = new DecimalFormat("0.00");
//        DecimalFormat df = new DecimalFormat("##0.00");
//        BigDecimal a1 = new BigDecimal("0");
//        BigDecimal a2 = new BigDecimal("0.123");
//        BigDecimal a3 = new BigDecimal("11.245");
//        System.out.println(df.format(a1));  //0.00
//        System.out.println(df.format(a2));  //0.12
//        System.out.println(df.format(a3));  //11.24

        DecimalFormat df = new DecimalFormat("#,##0.00");
        BigDecimal a1 = new BigDecimal("0");
        BigDecimal a2 = new BigDecimal("0.123");
        BigDecimal a3 = new BigDecimal("11.24545");
        BigDecimal a4 = new BigDecimal("3345611.24545");
        System.out.println(df.format(a1));  //0.00
        System.out.println(df.format(a2));  //0.12
        System.out.println(df.format(a3));  //11.25
        System.out.println(df.format(a4));  //3,345,611.25
}