BigDecimal是不可变、任意精度的有符号 十进制数。

一般是用在大金额结算等对数值精度要求较高的领域(因为浮点数如float、double表示小数的精确度不足，仅可以处理16位有效数字)，但其运算性能低于Double、Float等，在一般的工程领域数值计算也不会随便用BigDecimal。

Java BigDecimal 的舍入模式 （RoundingMode）详解

值得注意的是，除法一般都是需要确定保留多少位小数的BigDecimal
bigDecimal = a.divide(b,2,RoundingMode.HALF_UP);，如果不设置保留的小数位Scale，就可能会抛出ArithmeticException异常。这是因为a.divide(b)会默认使用ROUND_UNNECESSARY模式，即不做舍入处理，如果计算结果的小数位和要求保留的小数位不相符，则抛出异常。

下面假设如保留两位小数：(保留两位小数只关心第三位小数)，根据第三位小数为0 及<5、=5、>5的情况分析得出如下结论：
注意如果不足两位小数则填充0保证两位小数 还需要注意new BigDecimal("-0")(无论-0还是0)保留两位小数都是0.00
至于负数情况只是前面加个负号。

舍入策略	注意点	代码标志	对应源码值	核心功能特点
第三位小数只要>0 就进1	(0 除外)都会进1，负数加-即可	ROUND_UP	0	向上取整
第三位小数直接舍去	直接舍去，负数加-即可	ROUND_DOWN	1	向下取整
第三位小数>=5，进行四舍五入	负数加-即可	ROUND_HALF_UP	4	常规四舍五入
第三位小数>5，进行五舍六入	负数加-即可	ROUND_HALF_DOWN	5	常规五舍六入
如果为正数等价于：ROUND_UP；为负数等价于：ROUND_DOWN	ROUND_UP、ROUND_DOWN 的搭配正用	ROUND_CEILING	2	此模式会增加数值大小
如果为正数等价于：ROUND_DOWN；为负数等价于：ROUND_UP	ROUND_UP、ROUND_DOWN 的搭配逆用	ROUND_FLOOR	3	此模式不会增加数值大小
四舍六入五成双	四舍六入五考虑，五后非零就进一，五后为零看奇偶，五前为偶应舍去，五前为奇要进一	ROUND_HALF_EVEN	6	银行家算法
断言我对目标数保留的位数是否>=目标数的位数	无舍入逻辑即不需要舍入，不满足则会报错：ArithmeticException	ROUND_UNNECESSARY	7	具备断言(判断)功能

看以上表格我说一嘴：

1. RoundingMode取值范围0到7 否则报错：java.lang.IllegalArgumentException: Invalid rounding mode
2. ROUND_HALF_EVEN 一般是业务中最常用的，也是这几种保留策略最复杂的，看完案例其实还是很简单的，技巧是 四舍六入五考虑，五后非零就进一(原数位数比你要保留的位数多至少2位)，五后为零看奇偶，五前为偶应舍去，五前为奇要进一
3. 对表格里面说法不理解请看下面具体每个的案例。
   可参考此内容
   ROUND_UP
   进位制：不管保留数字后面是大是小 (0 除外) 都会进 1。结果会向原点的反方向对齐，
   正数向正无穷方向对齐，负数向负无穷方向对齐。

        BigDecimal a = new BigDecimal("0.090").setScale(2, 0); // 0.09BigDecimal a1 = new BigDecimal("0.091").setScale(2, BigDecimal.ROUND_UP); // 0.10BigDecimal a2 = new BigDecimal("-0.090").setScale(2, BigDecimal.ROUND_UP); // -0.09BigDecimal a3 = new BigDecimal("-0.091").setScale(2, BigDecimal.ROUND_UP); // -0.10BigDecimal a4 = new BigDecimal("-0.1").setScale(2, BigDecimal.ROUND_UP); // -0.10BigDecimal a5 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_UP); // 0.00

ROUND_DOWN
舍去制，截断操作，后面所有数字直接去除。结果会向原点方向对齐。

        BigDecimal a = new BigDecimal("0.090").setScale(2, 1); // 0.09BigDecimal a1 = new BigDecimal("0.091").setScale(2, BigDecimal.ROUND_DOWN); // 0.09BigDecimal a2 = new BigDecimal("-0.090").setScale(2, BigDecimal.ROUND_DOWN); // -0.09BigDecimal a3 = new BigDecimal("-0.091").setScale(2, BigDecimal.ROUND_DOWN); // -0.09BigDecimal a4 = new BigDecimal("-0.1").setScale(2, BigDecimal.ROUND_DOWN); // -0.10BigDecimal a5 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_DOWN); // 0.00

ROUND_HALF_UP
根据保留数字后一位 >=5 进行四舍五入。如果舍弃部分的最高位大于等于 5，向原点反方向对齐，否则向原点方向对齐。

        BigDecimal a = new BigDecimal("0.090").setScale(2, 4); // 0.09BigDecimal a1 = new BigDecimal("0.091").setScale(2, BigDecimal.ROUND_HALF_UP); // 0.09BigDecimal a2 = new BigDecimal("-0.091").setScale(2, BigDecimal.ROUND_HALF_UP); // -0.09BigDecimal a3 = new BigDecimal("0.095").setScale(2, BigDecimal.ROUND_HALF_UP); // 0.10BigDecimal a4 = new BigDecimal("-0.095").setScale(2, BigDecimal.ROUND_HALF_UP); // -0.10BigDecimal a5 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_HALF_UP); // 0.00

ROUND_HALF_DOWN
根据保留数字后一位 >5 进行五舍六入。如果舍弃部分的最高位大于 5，向原点反方向对齐，否则向原点方向对齐。 这种模式也就是我们常说的 “五舍六入”。

        BigDecimal a = new BigDecimal("0.095").setScale(2, 5); // 0.09BigDecimal a1 = new BigDecimal("0.095").setScale(2, BigDecimal.ROUND_HALF_DOWN); // 0.09BigDecimal a2 = new BigDecimal("-0.095").setScale(2, BigDecimal.ROUND_HALF_DOWN); // -0.09BigDecimal a3 = new BigDecimal("0.096").setScale(2, BigDecimal.ROUND_HALF_DOWN); // 0.10BigDecimal a4 = new BigDecimal("-0.096").setScale(2, BigDecimal.ROUND_HALF_DOWN); // -0.10BigDecimal a5 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_HALF_DOWN); // 0.00

ROUND_CEILING
向正无穷方向对齐，转换为正无穷方向最接近的数值。如果为正数，行为和 ROUND_UP 一样；
如果为负数，行为和 ROUND_DOWN 一样。此模式不会减少数值大小。

        BigDecimal a = new BigDecimal("0.095").setScale(2, 2); // 0.10BigDecimal a1 = new BigDecimal("0.095").setScale(2, BigDecimal.ROUND_CEILING); // 0.10BigDecimal a2 = new BigDecimal("-0.095").setScale(2, BigDecimal.ROUND_CEILING); // -0.09BigDecimal a3 = new BigDecimal("0.096").setScale(2, BigDecimal.ROUND_CEILING); // 0.10BigDecimal a4 = new BigDecimal("-0.096").setScale(2, BigDecimal.ROUND_CEILING); // -0.09BigDecimal a5 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_CEILING); // 0.00

ROUND_FLOOR
向负无穷方向对齐。如果为正数，行为和 ROUND_DOWN 一样；
如果为负数，行为和 ROUND_UP 一样。此模式不会增加数值大小。

        BigDecimal a = new BigDecimal("0.095").setScale(2, 3); // 0.09BigDecimal a1 = new BigDecimal("0.095").setScale(2, BigDecimal.ROUND_FLOOR); // 0.09BigDecimal a2 = new BigDecimal("-0.095").setScale(2, BigDecimal.ROUND_FLOOR); // -0.10BigDecimal a3 = new BigDecimal("0.096").setScale(2, BigDecimal.ROUND_FLOOR); // 0.09BigDecimal a4 = new BigDecimal("-0.096").setScale(2, BigDecimal.ROUND_FLOOR); // -0.10BigDecimal a5 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_FLOOR); // 0.00

ROUND_HALF_EVEN
技巧：>6或=5且前一位为奇数进1，4>或=5且前一位为偶数舍去
四舍六入五成双，如果舍弃部分的最高位大于等于六，或等于五并且前一位是奇数，向原点反方向对齐，否则向原点方向对齐。
如果舍弃部分左边的数字为奇数，则作 ROUND_HALF_UP；如果为偶数，则作ROUND_HALF_DOWN。
ROUND_HALF_UP 根据保留数字后一位 >=5 进行四舍五入。
ROUND_HALF_DOWN 根据保留数字后一位 >5 进行五舍六入。

四舍六入五考虑，五后非零就进一，五后为零看奇偶，五前为偶应舍去，五前为奇要进一。

        BigDecimal a = new BigDecimal("0.035").setScale(2, 6); // 0.04BigDecimal a1 = new BigDecimal("0.045").setScale(2, BigDecimal.ROUND_HALF_EVEN); // 0.04BigDecimal a2 = new BigDecimal("0.055").setScale(2, BigDecimal.ROUND_HALF_EVEN); // 0.06BigDecimal a3 = new BigDecimal("0.065").setScale(2, BigDecimal.ROUND_HALF_EVEN); // 0.06BigDecimal a4 = new BigDecimal("0.075").setScale(2, BigDecimal.ROUND_HALF_EVEN); // 0.08BigDecimal a5 = new BigDecimal("-0.035").setScale(2, 6); // -0.04BigDecimal a6 = new BigDecimal("-0.045").setScale(2, BigDecimal.ROUND_HALF_EVEN); // -0.04BigDecimal a7 = new BigDecimal("-0.055").setScale(2, BigDecimal.ROUND_HALF_EVEN); // -0.06BigDecimal a8 = new BigDecimal("-0.065").setScale(2, BigDecimal.ROUND_HALF_EVEN); // -0.06BigDecimal a9 = new BigDecimal("-0.075").setScale(2, BigDecimal.ROUND_HALF_EVEN); // -0.08BigDecimal a10 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_HALF_EVEN); // 0.00BigDecimal a11 = new BigDecimal("-0.0851").setScale(2, BigDecimal.ROUND_HALF_EVEN); // -0.09

ROUND_UNNECESSARY
注意点
1、无舍入逻辑即不需要舍入，
2、也就是作用 断言我对目标数保留的位数是否>=目标数的位数
断言请求的操作具有精确的结果，因此不需要舍入。
如果对获得非精确结果的操作指定此舍入模式，则抛出 ArithmeticException。

        //Exception in thread "main" java.lang.ArithmeticException: Rounding necessary//BigDecimal a = new BigDecimal("0.035").setScale(2,  BigDecimal.ROUND_UNNECESSARY);BigDecimal a1 = new BigDecimal("0.03").setScale(2, BigDecimal.ROUND_UNNECESSARY);//0.03BigDecimal a2 = new BigDecimal("0.3").setScale(2, BigDecimal.ROUND_UNNECESSARY);//0.30BigDecimal a3 = new BigDecimal("300").setScale(2, BigDecimal.ROUND_UNNECESSARY);//300.00BigDecimal a5 = new BigDecimal("-0.03").setScale(2, BigDecimal.ROUND_UNNECESSARY);//-0.03BigDecimal a6 = new BigDecimal("-0").setScale(2, BigDecimal.ROUND_UNNECESSARY); // 0.00

==RoundingMode取值范围0到7 ==
否则，java.lang.IllegalArgumentException: Invalid rounding mode

//BigDecimal a9 = new BigDecimal("-0").setScale(2, 8);//IllegalArgumentException

提一下银行家算法

BigDecimal和BigInteger

一个针对浮点一个针对整形操作。
当对数字精度要求比较高时使用，BigInteger是对比Long范围还大的数字操作，而BigDecimal是比double还要精确的数字操作
主要有加减乘除方法：add()相加, subtract()相减, multiply()相乘, divide()相除。
顺便说一下，java.util包中的Scanner类实现了nextBigInteger()和nextBigDecimal()方法，可以用来读入控制台输入的BigInteger和BigDecimal。

BigInteger i1 = new BigInteger("79846513898465139846513289653");
BigInteger i2 = new BigInteger("46513986539856298465398465132");
//add()相加,  subtract()相减,  multiply()相乘, divide()相除
BigInteger i3 = i1.add(i2);
System.out.println( i3 );
System.out.println( i1.subtract(i2));
System.out.println( i1.multiply(i2));
System.out.println( i1.divide(i2));

//小数有可能会出现除不断的情况
BigDecimal d1 = new BigDecimal("79846597846513984653978465.985");
BigDecimal d2 = new BigDecimal("465132645132978465.985");
//小数相除,如果除不断就会产生java.lang.ArithmeticException算术异常
//小数相除时,经常指定小数的位数（这里保留10位小数）, 及尾数的处理方式System.out.println( d1.divide(d2, 10, RoundingMode.FLOOR));
//RoundingMode是一种枚举类型, 枚举可以看作是一组常量的组合
//枚举也是一种引用数据类型, 可以定义变量, 赋值时只能赋值枚举类型中定义的常量值
RoundingMode  mode = RoundingMode. ROUND_HALF_UP;// 表示的就是4舍5入

下面说点不重要的东西，多知道一点

numBits范围非负数即>=0

        System.out.println("构造两个BigInteger对象");BigInteger bi1 = new BigInteger(55,new Random());BigInteger bi2 = new BigInteger(new byte[]{3,2,3});System.out.println("bi1 + bi2 = " + bi1.add(bi2));  //加System.out.println("bi1 - bi2 = " + bi1.subtract(bi2));    //减System.out.println("bi1 * bi2 = " + bi1.multiply(bi2));  //乘System.out.println("bi1的2次方 = " + bi1.pow(2)); //指数运算//因为是整形我就不存在小数，小数根据舍入规则舍弃了System.out.println("bi1/bi2的整数商: " + bi1.divide(bi2));  //整数商System.out.println("bi1/bi2的余数: " + bi1.remainder(bi2));//余数//todo  整数商+余数System.out.println("bi1 / bi2 = " + bi1.divideAndRemainder(bi2)[0] +"--" + bi1.divideAndRemainder(bi2)[1]);System.out.println("bi1 + bi2 = " + bi1.add(bi2));//比较大小,也可以用max()和min() if(bi1.compareTo(bi2) > 0){System.out.println("bi1 is greater than bi2");}else if(bi1.compareTo(bi2) == 0){System.out.println("bi1 is equal to bi2");}else if(bi1.compareTo(bi2) < 0){System.out.println("bd1 is lower than bd2");}BigInteger bi3 = bi1.negate();System.out.println("bi1的相反数:" + bi3);   //返回相反数System.out.println("bi1的绝对值:" + bi3.abs());//返回绝对值

转换进制

String string1 = new BigInteger("20", 10).toString(2);System.out.println("TAG 十进制的20转换成二进制是：" + string1);String string2 = new BigInteger("20", 10).toString(8);System.out.println("TAG 十进制的20转换成八进制是：" + string2);String string3 = new BigInteger("20", 10).toString(16);System.out.println("TAG 十进制的20转换成十六进制是：" + string3);String string4 = new BigInteger("110", 2).toString(10);System.out.println("TAG 二进制的110转换成十进制是：" + string4);String string5 = new BigInteger("110", 8).toString(10);System.out.println("TAG 八进制的110转换成十进制是：" + string5);String string6 = new BigInteger("110", 16).toString(10);System.out.println("TAG 十六进制的110转换成十进制是：" + string6);

Java中BigDecimal常用方法

来点不一样的玩法

System.out.println("构造两个BigDecimal对象");//用char[]数组创建BigDecimal对象,第二个参数为位移offset, 第三个参数指定长度BigDecimal bd1 = new BigDecimal("3464656776868432998434".toCharArray(), 2, 15);//用double类型创建BigDecimal对象 下面肯定会精度丢失BigDecimal bd2 = new BigDecimal(134258767575867.0F);System.out.println("bd1 + bd2 = " + bd1.add(bd2)); //加System.out.println("bd1 - bd2 = " + bd1.subtract(bd2));//减System.out.println("bd1 * bd2 = " + bd1.multiply(bd2));//乘System.out.println("bd1的2次方 = " + bd1.pow(2));//指数运算//todo 取商的整数部分System.out.println("bd1/bd2的整数商: " + bd1.divideToIntegralValue(bd2));
//        返回余数计算为:this.subtract(this.divideToIntegralValue(divisor).multiply(divisor))System.out.println("bd1/bd2的余数: " + bd1.subtract(bd1.divideToIntegralValue(bd2).multiply(bd2)));System.out.println("bd1/bd2的余数: " + bd1.remainder(bd2));//取商和余,即bd1.divideToIntegralValue(bd2)与bd1.remainder(bd2)System.out.println("bd1 / bd2 = " + bd1.divideAndRemainder(bd2)[0] +"--" + bd1.divideAndRemainder(bd2)[1]);//比较大小,也可以用max()和min()if (bd1.compareTo(bd2) > 0) {System.out.println("bd1 is greater than bd2");} else if (bd1.compareTo(bd2) == 0) {System.out.println("bd1 is equal to bd2");} else if (bd1.compareTo(bd2) < 0) {System.out.println("bd1 is lower than bd2");}//末位数据精度 整数为1 小数为其小数点精度//返回该BigDecimal的最后一个单位ulp的大小。非零BigDecimal值的ulp是该值与具有相同位数的下一个较大的BigDecimal值之间的正距离。// ulp为0时，在这个比例下数值等于1。结果以相同的比例存储，因此0和非0值的结果等于[1,this.scale()]。System.out.println("bd1的末位数据精度:  " + bd1.ulp());System.out.println("末位数据精度:  " + new BigDecimal("123.21").ulp());//0.01System.out.println("末位数据精度:  " + new BigDecimal("123.21134").ulp());//0.00001System.out.println("末位数据精度:  " + new BigDecimal("123").ulp());//1System.out.println("末位数据精度:  " + new BigDecimal("0").ulp());//1

为什么说总是使用compareTo()比较两个BigDecimal的值，不要使用equals()！
BigDecimal d1 = new BigDecimal(“123.456”);

操作数据工具类，

比如±*/的基本操作，还有，相反数，最大公约数，是否是质数等等的运算。
BigDecimal转BigInteger
获取小数位数、小数精度，绝对值、不绝对值、取反、去除小数点后无用0、
取商的整数部分、取余数、返回商跟余数、
返回一个BigDecimal，设置指定保留位数，及舍入策略。
返回BigDecimal和val的最大值、最小值。
向左向右移动小数点的方法、判断一个数是正数、0、还是负数

 /*** 获取小数位数*/public static int getScale(BigDecimal b) {return b.scale();}//上面的升级版，去掉后面的0public static int getScale2(BigDecimal b) {return  b.stripTrailingZeros().scale();}/*** 获取小数精度 大于6位小数后采用科学计数法* 末位数据精度 整数为1 小数为其小数点精度*/public static BigDecimal getUlpDecimal(BigDecimal b) {return b.ulp();}//去除末尾无用的0后的小数精度public static BigDecimal getUlpDecimal2(BigDecimal b) {return  b.stripTrailingZeros().ulp();}/*** 方法返回此BigDecimal的精度。精度是指非标度值中的位数。* 这个不会科学计数，但是返回值跟上面不一样，* 此方法返回一个整数，该整数表示此BigDecimal对象的精度。* Input : 198.176 Output : 6 * Input : 721111.111 Output : 9* Input : 0.3 Output : 1* */public static int precisionBigDecimal(BigDecimal bd){return bd.precision();}public static int precisionBigDecimal2(BigDecimal bd){return bd.stripTrailingZeros().precision();}/*** 获取绝对值---负数转正数*/public static BigDecimal getABSBigDecimal(BigDecimal b) {return b.abs();}/*** 跟绝对值反着来---正数转负数*/public static BigDecimal getNotABSBigDecimal(BigDecimal b) {BigDecimal abs = b.abs();return new BigDecimal("-" + b.abs());}/*** 返回相反数---正数转负数,负数转正数(作用就是负数去负号，正数加负号)* 如果你需要进行取舍的话他还支持 传参MathContext.  具体规则自行百度*/public static BigDecimal getNegateBigDecimal(BigDecimal b) {return b.negate();}/*** 取商的整数部分(直接把小数舍去)* bd1/bd2的整数商*/public static BigDecimal getDivShang(BigDecimal bd1, BigDecimal bd2) {return bd1.divideToIntegralValue(bd2);}/*** 返回余数计算 (直接把小数舍去)* bd1/bd2的整数商*/public static BigDecimal getDivMod(BigDecimal bd1, BigDecimal bd2) {return bd1.remainder(bd2);
//        return  bd1.subtract(bd1.divideToIntegralValue(bd2).multiply(bd2));}/*** 取商和余,即bd1.divideToIntegralValue(bd2)与bd1.remainder(bd2)*/public static String getDivShangAndMod(BigDecimal bd1, BigDecimal bd2) {return bd1.divideAndRemainder(bd2)[0] + "余" + bd1.divideAndRemainder(bd2)[1];}/*** 返回一个BigDecimal，它在数值上与此值相等，但从表示形式中移除尾随的任何零。*/public static BigDecimal getTrailingZeros(BigDecimal bd1) {return bd1.stripTrailingZeros();}/*** 返回一个BigDecimal，设置指定保留位数，及舍入策略*/public static BigDecimal getTargetScale(BigDecimal bd1,int numWei,int ceLue) {return bd1.setScale(numWei,ceLue);}/*** 返回BigDecimal和val的最大值，相等返回bd1*/public static BigDecimal getMaxBigDecimal(BigDecimal bd1,BigDecimal bd2) {return bd1.max(bd2);}/*** 返回BigDecimal和val的最小值，相等返回bd1*/public static BigDecimal getMinBigDecimal(BigDecimal bd1,BigDecimal bd2) {return bd1.min(bd2);}/*** 将该值的小数点移动n位到左边。如果n为非负，则调用仅将n添加至刻度。如果n为负时，调用相当于调用movePointRight(-n)。*/
public static BigDecimal movePointLeftBigDecimal(BigDecimal bd,int num){return bd.movePointLeft(num);
}public static BigDecimal movePointRightBigDecimal(BigDecimal bd,int num){return bd.movePointRight(num);}/*** 看你是正数负数还是0* 基于此BigDecimal返回这三个值[-1、1或0]中的任何一个*/public static int signumBigDecimal(BigDecimal bd){return bd.signum();}/*** BigDecimal转BigInteger*/public static BigInteger BigDecimalToBigInteger(BigDecimal decimal) {return decimal.toBigInteger();}/*** 最大公约数* @return*/public static BigInteger bigIntegerGcd(BigInteger bigInteger1, BigInteger bigInteger2) {return bigInteger1.gcd(bigInteger2);}/*** 如果BigInteger可能是质数，则返回true，如果绝对是合数则返回false。如果确定性≤0，则返回true*/
public static boolean BigIntegerIsProbablePrime(BigInteger integer) {return integer.isProbablePrime(2);
}

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.NumberFormat;/*** BigDecimal、Double、String之间的互转* 加减乘除的方法，都是重载方法，根据需求可扩容仿写即可(注意这块默认四舍五入策略，具体根需求修改)* 提供BigDecimal、Double、String之间的精确的小数位四舍五入处理* 两个数相除取余数* 两个数比较大小* <p>* <p>* 把阿拉伯数字转换为罗马数字:intToRomanNum* 把罗马数字转换为阿拉伯数字:romanNumToInt* int 转 中文数字:intTochineseNum(缺陷数字只能到亿)* bigDecimal（包含小数点） 转中文数字  bigDecimalTochineseNum(缺陷整数数字只能到亿)* 将任意长度的字符串str转换为中国传统金额表示方式:convertChineseNum (缺陷数字不支持小数)* 及正常金额 convertHanNum (缺陷数字不支持小数)* <p>*     下面方法在使用时候先去看一下方法，返回特点是不是想要的* BigDecimal货币格式化 currencyFormat* BigDecimal百分比格式化 rateFormat*/
public class BigDecimalArithmeticUtils {private BigDecimalArithmeticUtils() {}//默认除法运算精度  保留10位小数private static final int DEF_DIV_SCALE = 10;/*** BigDecimal转Double** @param bigDecimal* @return*/public static double BigDecimalToDouble(BigDecimal bigDecimal) {return bigDecimal.doubleValue();}/*** BigDecimal转String** @param bigDecimal* @return*/public static String BigDecimalToString(BigDecimal bigDecimal) {return bigDecimal.toString();}/*** Double转BigDecimal** @param v* @return*/public static BigDecimal DoubleToBigDecimal(double v) {return new BigDecimal(Double.toString(v));}/*** Double转String** @param v* @return*/public static String DoubleToString(double v) {return Double.toString(v);}/*** 提供精确的加法运算** @param v1 被加数* @param v2 加数* @return 两个参数的和*/public static double addReturnDouble(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.add(b2).doubleValue();}public static BigDecimal add(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.add(b2);}/*** 提供精确的加法运算** @param v1 被加数* @param v2 加数* @return 两个参数的和*/public static BigDecimal add(String v1, String v2) {BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.add(b2);}/*** 提供精确的加法运算** @param v1    被加数* @param v2    加数* @param scale 保留scale 位小数* @return 两个参数的和*/public static String add(String v1, String v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}/*** 精确的加法运算，并对运算结果截位.*/public static BigDecimal add(BigDecimal b1, BigDecimal b2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP);}public static String add(double v1, double v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}/*** 提供精确的减法运算** @param v1 被减数* @param v2 减数* @return 两个参数的差*/public static double subReturnDouble(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.subtract(b2).doubleValue();}public static BigDecimal sub(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.subtract(b2);}/*** 提供精确的减法运算。** @param v1 被减数* @param v2 减数* @return 两个参数的差*/public static BigDecimal sub(String v1, String v2) {BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.subtract(b2);}/*** 提供精确的减法运算** @param v1    被减数* @param v2    减数* @param scale 保留scale 位小数* @return 两个参数的差*/public static String sub(String v1, String v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}public static String sub(double v1, double v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}public static BigDecimal sub(BigDecimal v1, BigDecimal v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}return v1.subtract(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);}/*** 提供精确的乘法运算** @param v1 被乘数* @param v2 乘数* @return 两个参数的积*/public static double mulReturnDouble(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.multiply(b2).doubleValue();}public static BigDecimal mul(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.multiply(b2);}/*** 提供精确的乘法运算** @param v1 被乘数* @param v2 乘数* @return 两个参数的积*/public static BigDecimal mul(String v1, String v2) {BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.multiply(b2);}public static BigDecimal mul(BigDecimal v1, BigDecimal v2) {return v1.multiply(v2);}/*** 提供精确的乘法运算** @param v1    被乘数* @param v2    乘数* @param scale 保留scale 位小数* @return 两个参数的积*/public static double mul(double v1, double v2, int scale) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return round(b1.multiply(b2).doubleValue(), scale);}/*** 提供精确的乘法运算** @param v1    被乘数* @param v2    乘数* @param scale 保留scale 位小数* @return 两个参数的积*/public static String mul(String v1, String v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}public static BigDecimal mul(BigDecimal v1, BigDecimal v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}return v1.multiply(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);}/*** 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到* 小数点以后10位，以后的数字四舍五入** @param v1 被除数* @param v2 除数* @return 两个参数的商*/public static double div(double v1, double v2) {return divReturnDouble(v1, v2, DEF_DIV_SCALE);}/*** 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指* 定精度，以后的数字四舍五入** @param v1    被除数* @param v2    除数* @param scale 表示表示需要精确到小数点以后几位。* @return 两个参数的商*/public static double divReturnDouble(double v1, double v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();}public static BigDecimal divide(BigDecimal b1, BigDecimal b2) {return b1.divide(b2);}public static BigDecimal div(double v1, double v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP);}public static BigDecimal div(BigDecimal v1, BigDecimal v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}return v1.divide(v2, scale, BigDecimal.ROUND_HALF_UP);}/*** 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指* 定精度，以后的数字四舍五入** @param v1    被除数* @param v2    除数* @param scale 表示需要精确到小数点以后几位* @return 两个参数的商*/public static String div(String v1, String v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v1);return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();}/*** 提供精确的小数位四舍五入处理** @param v     需要四舍五入的数字* @param scale 小数点后保留几位* @return 四舍五入后的结果*/public static double round(double v, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b = new BigDecimal(Double.toString(v));return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();}public static BigDecimal round(BigDecimal v, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}return v.setScale(scale, BigDecimal.ROUND_HALF_UP);}/*** 提供精确的小数位四舍五入处理** @param v     需要四舍五入的数字* @param scale 小数点后保留几位* @return 四舍五入后的结果*/public static String round(String v, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b = new BigDecimal(v);return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}/*** 取余数** @param v1    被除数* @param v2    除数* @param scale 小数点后保留几位* @return 余数*/public static String remainder(String v1, String v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}public static String remainder(double v1, double v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();}/*** 取余数  BigDecimal** @param v1    被除数* @param v2    除数* @param scale 小数点后保留几位* @return 余数*/public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {if (scale < 0) {throw new IllegalArgumentException("The scale must be a positive integer or zero");}return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);}/*** 比较大小** @param v1 被比较数* @param v2 比较数* @return 如果v1 大于v2 则 返回true 否则false*/public static boolean compare(String v1, String v2) {BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);int bj = b1.compareTo(b2);boolean res;if (bj > 0)res = true;elseres = false;return res;}public static int compareInt(String v1, String v2) {BigDecimal b1 = new BigDecimal(v1);BigDecimal b2 = new BigDecimal(v2);return b1.compareTo(b2);}public static boolean compare(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));int bj = b1.compareTo(b2);boolean res;if (bj > 0)res = true;elseres = false;return res;}public static int compareInt(double v1, double v2) {BigDecimal b1 = new BigDecimal(Double.toString(v1));BigDecimal b2 = new BigDecimal(Double.toString(v2));return b1.compareTo(b2);}public static boolean compare(BigDecimal v1, BigDecimal v2) {int bj = v1.compareTo(v2);boolean res;if (bj > 0)res = true;elseres = false;return res;}//比较BigDecimal,相等返回0,v1>v2 返回1, v1<v2 返回-1public static int compareInt(BigDecimal v1, BigDecimal v2) {return v1.compareTo(v2);}//建立货币格式化引用private static final NumberFormat currency = NumberFormat.getCurrencyInstance();/*** "10042356.325354" ===>  ￥10,042,356.33    100456 ===>  ￥100,456.00* BigDecimal货币格式化 currencyFormat** @param money* @return*/public static String currencyFormat(BigDecimal money) {return currency.format(money);}/*** 将数字转换成带逗号的字符串（"###,##0.## "）* @param reg 格式化串* @param number 需要转换的数字* @return*/public static String numberFormart(String reg,double number){DecimalFormat bf = new DecimalFormat(reg);return bf.format(number);}//建立百分比格式化引用private static final NumberFormat percent = NumberFormat.getPercentInstance();/*** BigDecimal百分比格式化* 0.12 ====>12%  1.4 ===>140%* 0.005 ==> 0%   0.015==>2%    0.1445==>14%* @param rate* @return*/public static String rateFormat(BigDecimal rate) {return percent.format(rate);}/*** double类型的数字转化为百分之** @param doubleNum*            double类型* @return eg:类似21%的百分之*/public static String double2Percent(double doubleNum) {DecimalFormat df = new DecimalFormat("##.00%");if (doubleNum == 0.0)return "0%";return df.format(doubleNum);}public static String double2Percent(BigDecimal doubleNum) {DecimalFormat df = new DecimalFormat("##.00%");
//        if (doubleNum == 0.0)
//            return "0%";return df.format(doubleNum);}public static String double2Percent(String doubleNum) {DecimalFormat df = new DecimalFormat("##.00%");
//        if (doubleNum == 0.0)
//            return "0%";return df.format(doubleNum);}/*** 把阿拉伯数字转换为罗马数字  intToRomanNum* 罗马数字是古罗马使用的数字系统,现今仍很常见。罗马数字共有7个，* 即Ⅰ(1)，Ⅴ(5)，Ⅹ(10)，Ⅼ(50)，Ⅽ(100)，Ⅾ(500)，Ⅿ(1000)。* 需要注意的是罗马数字中没有“0”。** @param number* @return 小于1大于3999 返回-1*/public static String intToRomanNum(int number) {String rNumber = "";int[] aArray = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};String[] rArray = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X","IX", "V", "IV", "I"};if (number < 1 || number > 3999) {rNumber = "-1";} else {for (int i = 0; i < aArray.length; i++) {while (number >= aArray[i]) {rNumber += rArray[i];number -= aArray[i];}}}return rNumber;}/*** 把罗马数字转换为阿拉伯数字** @param m* @return*/public static int romanNumToInt(String m) {int graph[] = new int[400];graph['I'] = 1;graph['V'] = 5;graph['X'] = 10;graph['L'] = 50;graph['C'] = 100;graph['D'] = 500;graph['M'] = 1000;char[] num = m.toCharArray();int sum = graph[num[0]];for (int i = 0; i < num.length - 1; i++) {if (graph[num[i]] >= graph[num[i + 1]]) {sum += graph[num[i + 1]];} else {sum = sum + graph[num[i + 1]] - 2 * graph[num[i]];}}return sum;}/*** 中文数字*/private static final String[] CN_NUM = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};/*** 中文数字单位*/private static final String[] CN_UNIT = {"", "十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千"};/*** 特殊字符：负*/private static final String CN_NEGATIVE = "负";/*** 特殊字符：点*/private static final String CN_POINT = "点";/*** int 转 中文数字* 支持到int最大值** @param intNum 要转换的整型数* @return 中文数字*/public static String intTochineseNum(int intNum) {StringBuffer sb = new StringBuffer();StringBuffer sb2 = new StringBuffer();int intNum2 = intNum;boolean isNegative = false;if (intNum < 0) {isNegative = true;intNum *= -1;}int count = 0;while (intNum > 0) {sb.insert(0, CN_NUM[intNum % 10] + CN_UNIT[count]);intNum = intNum / 10;count++;}if (isNegative)sb.insert(0, CN_NEGATIVE);// 10-19时,得到十~十九而不是一十~一十九sb = "一".equals(sb.substring(0, 1)) && intNum2 < 100 && intNum2 > 1 ? sb2.append(sb.substring(1, sb.length())) : sb;return sb.toString().replaceAll("零[千百十]", "零").replaceAll("零+万", "万").replaceAll("零+亿", "亿").replaceAll("亿万", "亿零").replaceAll("零+", "零").replaceAll("零$", "");}/*** bigDecimal 转 中文数字  bigDecimalTochineseNum* 整数部分只支持到int的最大值** @param bigDecimalNum 要转换的BigDecimal数* @return 中文数字*/public static String bigDecimalTochineseNum(BigDecimal bigDecimalNum) {if (bigDecimalNum == null)return CN_NUM[0];StringBuffer sb = new StringBuffer();//将小数点后面的零给去除String numStr = bigDecimalNum.abs().stripTrailingZeros().toPlainString();String[] split = numStr.split("\\.");String integerStr = intTochineseNum(Integer.parseInt(split[0]));sb.append(integerStr);//如果传入的数有小数，则进行切割，将整数与小数部分分离if (split.length == 2) {//有小数部分sb.append(CN_POINT);String decimalStr = split[1];char[] chars = decimalStr.toCharArray();for (int i = 0; i < chars.length; i++) {int index = Integer.parseInt(String.valueOf(chars[i]));sb.append(CN_NUM[index]);}}//判断传入数字为正数还是负数int signum = bigDecimalNum.signum();if (signum == -1) {sb.insert(0, CN_NEGATIVE);}return sb.toString();}/*** 将任意长度的字符串str转换为中国传统金额表示方式，打印到控制台上* 金额转换，阿拉伯数字转换成中国传统形式。* 例如：101000001010   转换为   壹仟零壹拾亿零壹仟零壹拾圆整* 注意：00101000000010等价101000000010 去除非法零* 本题实现比较复杂，主要是对连续的零的判断，通过循环判断每一位及前一位是否为零，来控制是否删除多余的零。* 实现了对任意长度的字符串的金额转换。*/public static String convertChineseNum(String str) {//使用正则表达式判断字符串格式是否为数字格式if (!str.matches("\\d+")) {return "字符串" + str + "不是数字格式，无法转换！";}//将字符串最前面的0去掉while (str.startsWith("0")) {str = str.substring(1, str.length());}//将字符串数字替换成中文数字char[] num = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};char[] cnNum = new char[]{'零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'};for (int i = 0; i < 10; i++) {str = str.replace(num[i], cnNum[i]);}StringBuilder sb = new StringBuilder(str);//StringBuilder存放字符串，用于插入删除操作int index = str.length() - 1;   //从第index个字符从后往前开始操作，操作一次，index--//存放金额单位String[] unit = {"", "拾", "佰", "仟"};String[] unit4 = {"万", "亿"};boolean flag = false;//判断前一个数是否为零的标记for (int i = 0; i < str.length(); i++) {//循环体内对sb进行操作//每4位插入万每8位插入亿，最低位先不设置单位if (i % 4 == 0 && i != 0) {//根据金额规则，单位万前面为4个零时，不插入万，并将index位置（最低位）的零删除if ((i / 4 - 1) % 2 == 0 && index >= 3 && str.substring(index - 3, index + 1).equals("零零零零")) {sb.deleteCharAt(index);index--;continue;}//否则在index+1位置插入相应的单位：万、亿sb.insert(index + 1, unit4[(i / 4 - 1) % 2]);}//如果4位的最低位为零，删除最低位的零，将零标志置为trueif (i % 4 == 0 && str.charAt(index) == '零') {sb.deleteCharAt(index);flag = true;index--;continue;}//如果前一位为零并且这一位也为零，删除这一位的零if (flag && str.charAt(index) == '零') {sb.deleteCharAt(index);index--;continue;}//如果当前位为零，将零标志置为trueif (str.charAt(index) == '零') {flag = true;index--;continue;}//当前位不为零，将零标志位置为false，插入金额单位flag = false;sb.insert(index + 1, unit[i % 4]);index--;}//完善金额表示形式sb.append("圆整");return sb.toString();}public static String convertHanNum(String str) {//使用正则表达式判断字符串格式是否为数字格式if (!str.matches("\\d+")) {return "字符串" + str + "不是数字格式，无法转换！";}//将字符串最前面的0去掉while (str.startsWith("0")) {str = str.substring(1, str.length());}//将字符串数字替换成中文数字char[] num = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};char[] cnNum = new char[]{'零', '一', '二', '三', '四', '五', '六', '七', '八', '九'};for (int i = 0; i < 10; i++) {str = str.replace(num[i], cnNum[i]);}StringBuilder sb = new StringBuilder(str);//StringBuilder存放字符串，用于插入删除操作int index = str.length() - 1;   //从第index个字符从后往前开始操作，操作一次，index--//存放金额单位String[] unit = {"", "十", "百", "千"};String[] unit4 = {"万", "亿"};boolean flag = false;//判断前一个数是否为零的标记for (int i = 0; i < str.length(); i++) {//循环体内对sb进行操作//每4位插入万每8位插入亿，最低位先不设置单位if (i % 4 == 0 && i != 0) {//根据金额规则，单位万前面为4个零时，不插入万，并将index位置（最低位）的零删除if ((i / 4 - 1) % 2 == 0 && index >= 3 && str.substring(index - 3, index + 1).equals("零零零零")) {sb.deleteCharAt(index);index--;continue;}//否则在index+1位置插入相应的单位：万、亿sb.insert(index + 1, unit4[(i / 4 - 1) % 2]);}//如果4位的最低位为零，删除最低位的零，将零标志置为trueif (i % 4 == 0 && str.charAt(index) == '零') {sb.deleteCharAt(index);flag = true;index--;continue;}//如果前一位为零并且这一位也为零，删除这一位的零if (flag && str.charAt(index) == '零') {sb.deleteCharAt(index);index--;continue;}//如果当前位为零，将零标志置为trueif (str.charAt(index) == '零') {flag = true;index--;continue;}//当前位不为零，将零标志位置为false，插入金额单位flag = false;sb.insert(index + 1, unit[i % 4]);index--;}return sb.toString();}
}

BigDecimal的toString()方法和toPlainString()方法

今天遇到个问题 税率竟然采取了科学计数法，该数据类型是BigDecimal 通过 toString转成String类型的。后来换成toPlainString()方法进行解决的，下面分析一下

toString方法会将BigDecimal的值以科学计数方式的字符串

但是转换成科学计数的方式也是有场景的，并不是所有的值都会转为科学计数方式的字符串。
首先，任何一个BigDecimal都可以使用一个公式表示： unscaledValue × 10-scaleunscaledValue ：整数非标度值 （即去掉小数点的Bigdecimal的值，类型为BigInteger）
scale：标度值，如果为零或正数，则标度是小数点后的位数。如果为负数，则将该数的非标度值乘以 10 的负 scale 次幂。

toPlainString()方法是一个非静态方法，仅可通过类对象访问，如果尝试使用类名访问该方法，则会收到错误消息。原值输出为字符串

        String str1 = "12E+5";String str2 = "1200000";BigDecimal b_dec1 = new BigDecimal(str1);BigDecimal b_dec2 = new BigDecimal(str2);String str_conv = b_dec1.toPlainString();//1200000str_conv = b_dec2.toPlainString();//1200000String str3 = "12E+5";String str4 = "-12000000";BigDecimal b_dec1 = new BigDecimal(str3);BigDecimal b_dec2 = new BigDecimal(str4);//scale: -5  unscaledValue:12  toString:1.2E+6System.out.println("scale: "+b_dec1.scale()+"  unscaledValue:"+b_dec1.unscaledValue()+"  toString:"+b_dec1.toString());//scale: 0  unscaledValue:-12000000  toPlainString:-12000000System.out.println("scale: "+b_dec2.scale()+"  unscaledValue:"+b_dec2.unscaledValue()+"  toPlainString:"+b_dec2.toString());

当我们使用BigDecimal转成字符串时，大多其实是想单纯的使用toString方法，而并不想使用科学计数的方式，所以应该使用的是toPlainString方法

.stripTrailingZeros()会造成科学计数，也是我工作实际中遇到的，

        //一般直接使用 BigDecimal.toString()方法即可以完成浮点数的打印。System.out.println(new BigDecimal("10000000000").toString());//10000000000//但是，toString()方法输出的字符串并不能保证不是科学计数法。//不过在日常的使用中，用toString()方法输出的就是普通的数字字符串而非科学计数法。System.out.println( new BigDecimal("100.000").toString());//程序的输出即为：  100.000// 如果我们希望去除末尾多余的0，那么我们应该这么写：System.out.println( new BigDecimal("100.000").stripTrailingZeros().toString());//其中，stripTrailingZeros()函数就是用于去除末尾多余的0的，但是此时程序的输出为： 1E+2// 是科学计数法，可能并不是我们想要的。//解决的方法很简单，如果想要避免输出科学计数法的字符串，我们要用toPlainString()函数代替toString()。如：System.out.println( new BigDecimal("100.000").stripTrailingZeros().toPlainString());

Java中BigDecimal类常用方法，舍入策略相关推荐

1. java基础-BigDecimal类常用方法介绍

   java基础-BigDecimal类常用方法介绍 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.BigDecimal类概述 我们知道浮点数的计算结果是未知的.原因是计算机二进制 ...

2. Java中BigDecimal类介绍及用法

   Java中BigDecimal类介绍及用法 Java中提供了大数字(超过16位有效位)的操作类,即 java.math.BinInteger 类和 java.math.BigDecimal 类,用于高 ...

3. java 中date类常用方法

   1.Date 代表一个特定的时间,精确到毫秒: 方法名 说明 public Date() 创建一个Date对象,表示默认时间:把当前时间封装成Date对象 public Date(long date) ...

4. Java中String类常用方法（转）

   转自:https://blog.csdn.net/kaishizhangcheng/article/details/52332543 int indexOf(String str) 该方法用于返回当给 ...

5. Java中BigDecimal类的使用方法详解，常用最全系列！

   Java在java.math包中提供的API类BigDecimal,用来对超过16位有效位的数进行精确的运算.对于Double类型的运算,通常使用此类处理,来有效避免精度问题. 下面,我们从五个功能点 ...

6. java中(String)类常用方法

   作者简介: 博主在读计科双非本科,目前大二,正在学习JAVA,数据库,操作系统,计算机网络,数据结构,JAVA Web等- 个人主页:熬夜磕代码丶 作品专栏: java se 我变秃了,也变强了 给大 ...

7. Java中 ArrayList类常用方法和遍历

    ArrayList类对于元素的操作,基本体现在--增.删.查.常用的方法有: public boolean add(E e) :将指定的元素添加到此集合的尾部. public E remove(in ...

8. java中math的方法_Java中Math类常用方法代码详解

   近期用到四舍五入想到以前整理了一点,就顺便重新整理好经常见到的一些四舍五入,后续遇到常用也会直接在这篇文章更新... public class Demo{ public static void mai ...

9. java bigdecimal赋值_Java中BigDecimal类介绍及用法(亲测)

   Java中提供了大数字(超过16位有效位)的操作类,即 java.math.BinInteger 类和 java.math.BigDecimal 类,用于高精度计算. 其中 BigInteger 类是 ...

最新文章

1. matlab plot不均匀间隔,matplotlib如何绘制间隔为2^n的不均匀图形？
2. VC manifest
3. react native 报错：cannot read property 'length' of undefined
4. 第二周 数据分析之展示 Matplotlib基础绘图函数实例
5. easyui 动态设置单元格控件_插入控件-gt;引用变量-gt;实现动态图表纵横筛选
6. C语言如何返回格式化日期时间（格式化时间）？（将日期和时间以字符串格式输出）ctime()、asctime()、localtime()、strftime()
7. TZOJ 4621 Grammar(STL模拟)
8. 汇编指令的学习4——ldm/stm指令、栈的处理
9. 深度学习（三十七）优化求解系列之(1)简单理解梯度下降
10. 《Entity Framework 6 Recipes》中文翻译系列 (42) ------ 第八章 POCO之使用POCO
11. 系统目录WINDOWS下主要文件夹简介
12. 信号与系统公式笔记（9）——Z变换
13. html5设置谷歌浏览器兼容性,google浏览器
14. pop3协议解析及代码实现
15. kaggle下载output中的文件
16. css 文本属性 文本两端对齐 单行文本间距 首行缩进
17. 极光Im + layIm 实现后台聊天
18. 自定义通知图标音量电池没有的解决方法
19. 创造101：如果软件测试工程师组团出道，怎样才能站C位？！
20. 燕十八mysql笔记_学习笔记2..燕十八老师公益课堂

热门文章

1. 调试平衡小车过程中间遇到的问题
2. 使用Python自动给视频逐帧截图
3. uva 109 SCUD Busters-AC-Upgraded version
4. 职称计算机 frontpage 2003,高会职称计算机《Frontpage 2003网页制作》全部开通
5. 将微信公众号变为自动聊天机器人（一）引言
6. Advanced Science | 利用芽孢杆菌主导的具有独特合作模式的根际稳定核心菌群持续抑制玉米种传镰刀菌...
7. 制作一个圣诞快乐的卡片（python实现）
8. 测试人遇到难以重现的bug，要怎么办？
9. 网络语言为你打c,“想打定话给你”是什么梗
10. 格式工厂视频转换参数设置攻略