关于【BigDecimal】和Mysql中的decimal

> Mysql中的decimal的解释说明

decimal:数字型，不存在精度损失，常用于银行帐目计算

decimal(P,m)
P的取值范围是1–65，表示整数位数
M的取值是0–30.表示小数位
精度M最大为30，表示有30位小数。
decimal整数和小数位均不写 默认为decimal(10,0)
若小数位不写默认的小数位为0。

若存储的小数位比较多可以扩展整数位 decimal(22,6）整数位16个小数位6个。
在产品设计的时候可以约定。

decimal 还可以存储超过bigint的整数位，最大存储65位的整数类型。
还可以存储对应位数的负数

例：decimal(2,1)，此时，插入数据“12.3”、“12”等会出现“数据溢出错误”的异常；插入“1.23”或“1.2345…”会自动四舍五入成“1.2”；插入“2”会自动补成“2.0”，以确保2位的有效长度，其中包含1位小数。
当用 int类型会有溢出时，可以用 decimal 类型进行处理，把结果可以用 convert 或是 cast 进行转换。

>关于java中BigDecimal的简介

1、BigDecimal属于大数据，精度极高，不属于基本数据类型，属于java对象（引用数据类型）， 这是sun提供的一个类，专门用在财务软件中。
2、注意：财务软件中double是不够用的。
3、关于BigDecimal的方法

方法	说明
abs()函数	绝对值
toString();	将BigDecimal对象的数值转换成字符串。
setScale(int newScale, RoundingMode roundingMode);	需要对BigDecimal进行截断和四舍五入可用setScale方法
compareTo(BigDecimal val);	和另一个BigDecimal对比 等于1表示大于、等于0表示等于、等于-1表示小于
add(BigDecimal augend);	加
subtract(BigDecimal subtrahend);	减
multiply(BigDecimal multiplicand);	乘
divide(BigDecimal divisor, int scale, RoundingMode roundingMode);	除，第一参数表示被除数，第二个参数表示小数点后保留位数，第三个参数表示取舍规则(例如:四舍五入)

RoundingMode------说明（可以参考RoundingMode类）
ROUND_UP舍入远离零的舍入模式。1.1->2，-2.5->-3
ROUND_DOWN接近零的舍入模式。1.6->1，-2.5->-2
ROUND_CEILING接近正无穷大的舍入模式。
ROUND_FLOOR接近负无穷大的舍入模式。
ROUND_HALF_UP四舍五入
ROUND_HALF_DOWN
ROUND_HALF_EVEN
ROUND_UNNECESSARY

部分示例代码:

public class BigDecimalTest01 {
    public static void main(String[] args) {
//        这个100是精度极高的100
        BigDecimal v1 = new BigDecimal(100);
//        这个200是精度极高的200
        BigDecimal v2 = new BigDecimal(200);
//        求和
  // v1+v2 这样不行，v1和v2都是引用，不能直接使用+求和
  BigDecimal v3 = v1.add(v2);//调用方法求和
        System.out.println(v3);//300

        BigDecimal v4 = v2.divide(v1);//调用方法求商
        System.out.println(v4);//2
    }
}

其他方法调用类似

>>int与bigdecimal的相互转换

int转bigdecimal

BigDecimal number = new BigDecimal(0);
int value=score;
number=BigDecimal.valueOf((int)value);

bigdecimal转int

BigDecimal b=new BigDecimal(45.45);

int a = b.intValue();

>>String与bigdecimal的互转

当double必须用作BigDecimal的源时，可以使用BigDecimal的静态方法valueOf

BigDecimal num = NumberUtils.createBigDecimal(“123”);
org.apache.commons.lang.math

或者直接用bigdecimal的构造方法转换

>>转换中的精度丢失问题

注意：使用构造方法只能转换 String 和 int 类型，如果转换float或者double等浮点类型，会出现精度丢失的问题。原因：
我们点开构造器方法看下源码：

public static long doubleToLongBits(double value) {
    long result = doubleToRawLongBits(value);
    // Check for NaN based on values of bit fields, maximum
    // exponent and nonzero significand.
    if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
          DoubleConsts.EXP_BIT_MASK) &&
         (result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
        result = 0x7ff8000000000000L;
    return result;
}

问题就处在 doubleToRawLongBits 这个方法上，在 jdk 中 double 类（float 与 int 对应）中提供了 double 与 long 转换，doubleToRawLongBits 就是将 double 转换为 long，这个方法是原始方法（底层不是 java 实现，是 c++ 实现的）。

double 之所以会出问题，是因为小数点转二进制丢失精度。

所以，在涉及到精度计算的过程中，我们尽量使用 String 类型/或者转换为String再 来进行转换。

>>关于浮点类型的加减乘除 这里整理出一个 util 类供大家使用：

import java.math.BigDecimal;


public class BigDecimalUtils {
    public static BigDecimal doubleAdd(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2);
    }
    public static BigDecimal floatAdd(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.add(b2);
    }
    public static BigDecimal doubleSub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2);
    }
    public static BigDecimal floatSub(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.subtract(b2);
    }

    public static BigDecimal doubleMul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2);
    }
    public static BigDecimal floatMul(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.multiply(b2);
    }

    public static BigDecimal doubleDiv(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        // 保留小数点后两位 ROUND_HALF_UP = 四舍五入
        return b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);
    }
    public static BigDecimal floatDiv(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        // 保留小数点后两位 ROUND_HALF_UP = 四舍五入
        return b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);
    }
    /**
     * 比较v1 v2大小
     * @param v1
     * @param v2
     * @return v1>v2 return 1  v1=v2 return 0 v1<v2 return -1
     */
    public static int doubleCompareTo(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return  b1.compareTo(b2);
    }
    public static int floatCompareTo(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return  b1.compareTo(b2);
    }
}

>BigDecimal add 结果为0 解决

    public void testBigDecimal() {
        BigDecimal decimal = BigDecimal.ZERO;
 
        String x = "5";
 
        for (int i = 0; i < 3; i++) {
            decimal.add(new BigDecimal(x));
        }
        System.out.println(decimal);
    }

输出结果为 0

    public void testBigDecimal() {
        BigDecimal decimal = BigDecimal.ZERO;
 
        String x = "5";
 
        for (int i = 0; i < 3; i++) {
            decimal = decimal.add(new BigDecimal(x));
        }
        System.out.println(decimal);
    }

输出结果为 15
原因 : add 方法不会改变子身的值 需要一个值去接收结果

————————————————
版权声明：本文为优快云博主「「已注销」」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/weixin_45029643/article/details/103071680

>java中的取整与四舍五入方法实例(主要是BigDecimal的四舍五入)

>>一.java中取整数的方式

1.直接使用强制转换

public static void roundOne(){
  System.out.println("正数：(int)10.12 = " + (int)10.12); 
  System.out.println("负数：(int)-10.12 = " + (int)-10.12); 
  System.out.println("---------------------------------");
  System.out.println("正数：(int)1011111111111111111111.12 = " + (int)1011111111111111111111.12); 
  System.out.println("负数：(int)-1011111111111111111111.12 = " + (int)-1011111111111111111111.12); 
 }

直接用强制转换的方式将浮点型数据转换为整型时，直接去掉小数点后部分的精度，取整数部分；直接强制取整有精度风险，一方面是小数位损失，另一方面当浮点型数字超过整型数字最大值时，会发生溢出。实际工程中，如果这两种因素都不会对工程产生影响，可以使用，否则不建议使用。
2.java中提供的取整的函数
java中提供了三种取整的函数：

(1).Math.ceil(double num);

(2).Math.floor(double num);

(3).Math.round(double num);

 public static void roundTwo(){
  System.out.println("正数：Math.ceil(10.12) = " + Math.ceil(10.12));
  System.out.println("负数：Math.ceil(-10.12) = " + Math.ceil(-10.12));
  System.out.println("正数：Math.ceil(101111111111111111111.12) = " + Math.ceil(101111111111111111111.12));
  System.out.println("负数：Math.ceil(-101111111111111111111.12) = " + Math.ceil(-101111111111111111111.12));
  System.out.println("---------------------------------");
  System.out.println("正数：Math.floor(10.12) = " + Math.floor(10.12));
  System.out.println("负数：Math.floor(-10.12) = " + Math.floor(-10.12));
  System.out.println("正数：Math.floor(101111111111111111111.12) = " + Math.floor(101111111111111111111.12));
  System.out.println("负数：Math.floor(-101111111111111111111.12) = " + Math.floor(-101111111111111111111.12));
 }

Math.ceil(double num);函数是取浮点数的天花板数，即不小于num的最小整数；Math.floor(double num)函数是取地板数，即不大于num的最大整数。这两个函数的返回值均是double型（java中当其值大于9999999.0时，默认用科学记数法表示），如果超过没有特殊情况，或者说规则很明确，就一种规则。

public static void roundThree(){
  System.out.println("小数点后第一位=5"); 
  System.out.println("正数：Math.round(10.5) = " + Math.round(10.5)); 
  System.out.println("负数：Math.round(-10.5) = " + Math.round(-10.5)); 
  System.out.println(); 
 
  System.out.println("小数点后第一位<5"); 
  System.out.println("正数：Math.round(10.46) = " + Math.round(10.46)); 
  System.out.println("负数：Math.round(-10.46) = " + Math.round(-10.46)); 
  System.out.println(); 
 
  System.out.println("小数点后第一位>5"); 
  System.out.println("正数：Math.round(10.68) = " + Math.round(10.68)); 
  System.out.println("负数：Math.round(-10.68) = " + Math.round(-10.68));
 }

Math.round(double num)函数是取整函数，该函数只关注小数点后第一位小数值，具体规则如下：

(1).参数的小数点后第一位<5，运算结果为参数整数部分。

(2).参数的小数点后第一位>5，运算结果为参数整数部分绝对值+1，符号（即正负）不变。

(3).参数的小数点后第一位=5，正数运算结果为整数部分+1，负数运算结果为整数部分。

总结：大于五全部加，等于五正数加，小于五全不加。

>>二.Java中四舍五入的方法

1.使用BigDecimal对象的方式

public static void roundFour(){
  double f = 10.2345;
  BigDecimal b0 = new BigDecimal(f);
  BigDecimal b1 = new BigDecimal(f);
  BigDecimal b2 = new BigDecimal(f);
  BigDecimal b3 = new BigDecimal(f);
  BigDecimal b4 = new BigDecimal(f);
  BigDecimal b5 = new BigDecimal(f);
  BigDecimal b6 = new BigDecimal(f);
  BigDecimal b7 = new BigDecimal("10.2345");
  
  // 第一个参数是设置,保留的小数位数,3就是保留三位小数
  double f0 = b0.setScale(3, BigDecimal.ROUND_UP).doubleValue();
  double f1 = b1.setScale(3, BigDecimal.ROUND_DOWN).doubleValue();
  double f2 = b2.setScale(3, BigDecimal.ROUND_CEILING).doubleValue();
  double f3 = b3.setScale(3, BigDecimal.ROUND_FLOOR).doubleValue();
  double f4 = b4.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
  double f5 = b5.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
  double f6 = b6.setScale(3, BigDecimal.ROUND_HALF_EVEN).doubleValue();
  double f7 = b7.setScale(4, BigDecimal.ROUND_UNNECESSARY).doubleValue();
  
  System.out.println(f + "使用 远离零方向舍入（ROUND_UP）方式四舍五入结果为：" + f0);
  System.out.println(f + "使用 趋向零方向舍入（ROUND_DOWN）方式四舍五入结果为：" + f1);
  System.out.println(f + "使用 向正无穷方向舍入（ROUND_CEILING）方式四舍五入结果为：" + f2);
  System.out.println(f + "使用 向负无穷方向舍入（ROUND_FLOOR）方式四舍五入结果为：" + f3);
  System.out.println(f + "使用 最近数字舍入(5进)（ROUND_HALF_UP）方式四舍五入结果为：" + f4);
  System.out.println(f + "使用 最近数字舍入(5舍)（ROUND_HALF_DOWN）方式四舍五入结果为：" + f5);
  System.out.println(f + "使用 银行家舍入法（ROUND_HALF_EVEN）方式四舍五入结果为：" + f6);
  System.out.println(f + "使用 不需要舍入模式（ROUND_UNNECESSARY）方式结果为：" + f7);
 }

BigDecimal中有8种四舍五入设置方式：

(1).ROUND_UP:远离零方向舍入。向绝对值最大的方向舍入，只要舍弃位非0即进位。

(2).ROUND_DOWN:趋向零方向舍入。向绝对值最小的方向输入，所有的位都要舍弃，不存在进位情况。

(3).ROUND_CEILING:向正无穷方向舍入。向正最大方向靠拢。若是正数，舍入行为类似于ROUND_UP，若为负数，舍入行为类似于ROUND_DOWN。Math.round()方法就是使用的此模式。

(4).ROUND_FLOOR:向负无穷方向舍入。向负无穷方向靠拢。若是正数，舍入行为类似于ROUND_DOWN；若为负数，舍入行为类似于ROUND_UP。

(5).ROUND_HALF_UP:最近数字舍入(5进)。这是我们最经典的四舍五入。

(6).ROUND_HALF_DOWN:最近数字舍入(5舍)。在这里5是要舍弃的。

(7).ROUND_HALF_EVEN:银行家舍入法。

(8).ROUND_UNNECESSARY:计算结果是精确的，不需要舍入模式。

a.ROUND_HALF_DOWN解释

第(6)中四舍五入方式ROUND_HALF_DOWN解释的是遇到5要舍弃，但10.2345保留3位小数后结果是10.235，并没有直接舍去精确位的5，还是进了1，为什么呢？

public static void roundFive(){
  //通过double类型作为参数实例化BigDecimal对象
  double f = 10.2345;
  BigDecimal b5 = new BigDecimal(f);
  System.out.println("b5:" + b5);
  double f5 = b5.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
  System.out.println("ROUND_HALF_DOWN方式处理后：" + f5);
  System.out.println("----------------------------");
  //通过字符串类型作为参数实例化BigDecimal对象
  BigDecimal b5_1 = new BigDecimal("10.2345");
  System.out.println("b5_1:" + b5_1);
  double f5_1 = b5_1.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
  System.out.println("ROUND_HALF_DOWN方式处理后：" + f5_1);
  System.out.println("----------------------------");
  //遇到的5后面有小数位0，对数据大小无影响，直接舍弃5
  BigDecimal b5_2 = new BigDecimal("10.23450");
  System.out.println("b5_2:" + b5_2);
  double f5_2 = b5_2.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
  System.out.println("ROUND_HALF_DOWN方式处理后：" + f5_2);
  System.out.println("----------------------------");
  
  //遇到的5后面有非0小数位，对数据大小有影响，会进1
  BigDecimal b5_3 = new BigDecimal("10.234501");
  System.out.println("b5_3:" + b5_3);
  double f5_3 = b5_3.setScale(3, BigDecimal.ROUND_HALF_DOWN).doubleValue();
  System.out.println("ROUND_HALF_DOWN方式处理后：" + f5_3);
  System.out.println("----------------------------");
 }

通过例子可以看出，10.2345通过ROUND_HALF_DOWN方式保留三位小数后结果为10.235原因是，使用的double类型初始化产生的BigDecimal对象的，实际上实例化后的数值并不是10.2345，而是10.234500000000000596855898038484156131744384765625，根据样例可知，当5后面还有其他小数时，依然会向前进1位。也就是说当使用ROUND_HALF_DOWN方式时，并不是所有的5都直接舍去，需要看5后面是否有其他非0位，如果没有，直接舍去，如果有，需要进1。

b.银行家算法

四舍五入其实在金融方面运用的非常多，尤其是银行的利息。我们都知道银行的盈利渠道主要是利息差，它从储户手里收集资金，然后放贷出去，期间产生的利息差就是银行所获得的利润。如果我们采用平常四舍五入的规则话，这里采用每10笔存款利息计算作为模型，如下：

四舍：0.000、0.001、0.002、0.003、0.004。这些舍的都是银行赚的钱。

五入：0.005、0.006、0.007、0.008、0.009。这些入的都是银行亏的钱，

分别为：0.005、0.004、.003、0.002、0.001。

所以对于银行来说它的盈利应该是0.000 + 0.001 + 0.002 + 0.003 + 0.004 - 0.005 - 0.004 - 0.003 - 0.002 - 0.001 = -0.005。从结果中可以看出每10笔的利息银行可能就会损失0.005元，千万别小看这个数字，这对于银行来说就是一笔非常大的损失。面对这个问题就产生了如下的银行家涉入法了。该算法是由美国银行家提出了，主要用于修正采用上面四舍五入规则而产生的误差。如下：

(1).舍去位的数值小于5时，直接舍去。

(2).舍去位的数值大于5时，进位后舍去。

(3).当舍去位的数值等于5时，若5后面还有其他非0数值，则进位后舍去，若5后面是0时，则根据5前一位数的奇偶性来判断，奇数进位，偶数舍去。

对于上面的规则我们举例说明

11.556 = 11.56 ------六入
11.554 = 11.55 -----四舍
11.5551 = 11.56 -----五后有数进位
11.545 = 11.54 -----五后无数，若前位为偶数应舍去
11.555 = 11.56 -----五后无数，若前位为奇数应进位

c.ROUND_UNNECESSARY解释

ROUND_UNNECESSARY方式表示计算结果是精确的，如果不是精确的，将会抛出java.lang.ArithmeticException异常。

public static void roundSix(){
  BigDecimal b7 = new BigDecimal("10.23455");
  double f7 = b7.setScale(4, BigDecimal.ROUND_UNNECESSARY).doubleValue();
  System.out.println("ROUND_UNNECESSARY方式处理后：" + f7);
 }

如果将BigDecimal b7 = new BigDecimal(“10.23455”)中的数字改为10.2345或10.234500000;即可正常运行。也就是说，使用ROUND_UNNECESSARY方式时，浮点数保留N位小数时，不能影响数字的精度，只要有舍弃掉数字导致精度受影响，都会抛出异常。

注：这些枚举值有时候会用RoundingMode类中的枚举值，其实效果是一样的，RoundingMode只是将BigDecimal中的枚举又封装了一层，简化了一下枚举名，无实质性差别。RoundingMode枚举类中的枚举示例：UP(BigDecimal.ROUND_UP),
2.使用DecimalFormat对象的方式

public static void roundSeven(){
  DecimalFormat df = new DecimalFormat("#.000");
  //df.setRoundingMode(RoundingMode.DOWN);
  System.out.println(df.format(new BigDecimal(10.2345)));//10.235
 }

注：DecimalFormat默认采用了RoundingMode.HALF_EVEN这种类型,可以通过setRoundingMode方法进行设置四舍五入方式，而且format之后的结果是一个字符串类型String。
3.使用String.format方式

public static void roundEight(){
  double d = 10.2345;
  String result = String.format("%.3f", d);
  System.out.println("result:" + result);
 }

输出为10.235。String.format可以格式化很多类型的数据，包括整数、浮点数、字符串、日期等，具体对浮点数的格式化规则后续详细介绍，此处只需知道浮点数的四舍五入有这种方式。

4.使用Math.round方式

public static void roundNine(){
  double d1 = Math.round(5.2644555*100)*0.01d;
  System.out.println("d1:" + d1);
  
  double d2 = Math.round(5.2654555*100)*0.01d;
  System.out.println("d2:" + d2);
 }

Math.round()方式不建议使用，因为会有风险，如样例所示。

5.使用NumberFormat方式

public static void roundTen(){
  double d = 10.2345;
  NumberFormat nf=NumberFormat.getNumberInstance() ;
  nf.setMaximumFractionDigits(2);
  String s= nf.format(d) ;
  System.out.println("s1:" + s);
  
  nf.setMaximumFractionDigits(3);
  s= nf.format(d) ;
  System.out.println("s2:" + s);
 }