Java中的金钱陷阱-六虎

前言

有多少小伙伴是被标题骗吸引进来的呢，我可不是标题党，今天的文章呢确实跟”金钱“有联系。

可是咱们说的不是过度追求金钱而掉入圈套，而是要说一说在Java程序中，各种跟金钱运算有关的圈套。

日常工作中咱们经常会涉及到各种金额这样浮点数的运算。

一旦涉及到金额的运算就必须慎之又慎，一旦有精度丢掉，或者其他运算错误就或许形成无可挽回的丢失。

一、存在的圈套

这一末节咱们先将圈套列出来，下一末节分别给出解决计划。

咱们先来看看到底有哪些坑等着咱们去踩

1.1 浮点运算精度丢掉圈套

public class BigDecimalDemo {
    public static void main(String[] args) {
        float a = 1.0f - 0.9f;
        float b = 0.9f - 0.8f;
        System.out.println("a= "+a);
        System.out.println("b= "+b);
    }
}
//输出成果
a= 0.100000024
b= 0.099999964

1.2 浮点数等值判别圈套

① 根本类型与包装类型判别浮点数是否持平

public class BigDecimalDemo {
    public static void main(String[] args) {
        float a = 1.0F - 0.9F;
        float b = 0.9F - 0.8F;
        System.out.println("经过==判别a与b是否持平："+ (a == b));
        Float x = Float.valueOf(a);
        Float y = Float.valueOf(b);
        System.out.println("经过equals办法判别x与y是否持平："+ x.equals(y));
    }
}
//输出成果
经过==判别a与b是否持平false
经过equals办法判别x y是否持平false

②BigDecimal类经过equals 办法判别是否持平

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("2");
        BigDecimal b = new BigDecimal("2.0");
        System.out.println(a.equals(b));
    }
}
//输出成果
false

1.3 `BigDecimal` 结构办法中的圈套

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal(0.1f);
        System.out.println("a= "+ a);
    }
}
//输出成果
a= 0.100000001490116119384765625

1.4 `BigDecimal` 除法圈套

假如两数相除无法除尽，抛出 ArithmeticException 反常

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.2");
        BigDecimal b = new BigDecimal("0.3");
        System.out.println(a.divide(b));
    }
}
//输出成果
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
	at java.math.BigDecimal.divide(BigDecimal.java:1693)
	at com.xiezhr.BigDecimalDemo.main(BigDecimalDemo.java:17)

二、避免圈套

2.1 浮点数运算避坑

① 咱们先来看看为什么浮点数(也便是float 和double 关键字界说的数) 运算的时候精度会丢掉？

咱们直到核算机是以二进制的办法进行数据存储的，在表明一个数字时，宽度时有限的。

十进制的 0.1 转为二进制，得到一个无限循环小数：0.00011… （看不懂的自觉点回去翻一翻大一的《核算机基础》课本）

无限循环的小数存储在核算机时，只能被切断，所以就会导致小数精度发生丢失的状况。

这便是为什么浮点数没有办法用二进制准确表明。

②咱们怎么来填1.1 中的坑呢？

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("0.9");
        BigDecimal c = new BigDecimal("0.9");
        BigDecimal d = new BigDecimal("0.8");
        System.out.println("a-b = "+a.subtract(b));
        System.out.println("c-d = "+c.subtract(d));
    }
}
//输出成果
a-b = 0.1
c-d = 0.1

2.2 浮点数等值判别避坑

日常开发中肯守时免不了比较两个浮点数大小的，这儿呢就把1.2中的坑给填上

① 指定一个差错规模，若两个浮点数的差值在差错规模内，则以为两个浮点数时持平的

public class BigDecimalDemo {
    public static void main(String[] args) {
        float a = 1.0F - 0.9F;
        float b = 0.9F - 0.8F;
        //表明10的-6次方
        float diff = 1e-6f;
        if (Math.abs(a - b )< diff) {
            System.out.println("a与b持平");
        }
    }
}
//输出成果
a与b持平

② 运用BigDecimal界说值，再进行运算操作,最后运用compareTo 办法比较

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("0.9");
        BigDecimal c = new BigDecimal("0.8");
        BigDecimal x = a.subtract(b);
        BigDecimal y = b.subtract(c);
        if(x.compareTo(y)==0){
            System.out.println("x与y持平");
        }
    }
}
//输出成果
x与y持平

2.3 `BigDecimal` 结构办法避坑

圈套的发生：

double的结构办法的成果有一定的不可预知性,

newBigDecimal(1.0)所创建的实际上等于0.1000000000000000055511151231257827021181583404541015625。

因为0.1无法准确地表明为 double，传入到结构办法的值不会正好等于 0.1
String 结构办法是彻底可预知的

写入 newBigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1

这儿来填1.3中的坑，这儿有两种计划

《阿里巴巴Java开发手册》1.4 OOP 规约中提到

⓫ 【强制】 禁止运用结构办法BigDecimal(double)的办法把double值转化为BigDecimal 目标

阐明： BigDecimal(double) 存在精度丢失危险，在准确核算或值比较的场景中，或许会导致事务逻辑呈现反常。

如：BigDecimal g = new BigDecimal(0.1f); 实际存储值为：0.100000001490116119384765625

正例： 优先推荐入参为String 的结构办法，或运用BigDecimal 的 valueOf 办法。

此办法内部其实履行了Double 的toString, 而Double 的 toString 按double 的实际能表达的精度对尾数进行了切断。

BigDecimal good1 = new BigDecimal("0.1");
BigDecimal good2 = BigDecimal.valueOf(0.1);

①将BigDecimal(double) ==》BigDecimal(String)

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal(Double.toString(0.1));
        System.out.println("a=" + a);
    }
}
//输出成果
a=0.1

②运用BigDecimal类的valueOf 办法

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a =  BigDecimal.valueOf(0.1);
        System.out.println("a=" + a);
    }
}
//输出成果
a=0.1

2.4 `BigDecimal` 除法避坑

咱们运用带有3个参数的divide 办法来填1.4中的坑

BigDecimal.divide(BigDecimal divisor, int scale, RoundingMode roundingMode) 办法的详细运用咱们再下一末节中再详细说

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.2");
        BigDecimal b = new BigDecimal("0.3");
		//这儿就简单的看作四舍五入就行了
        System.out.println("a除以b等于："+ a.divide(b, 2, RoundingMode.HALF_UP));
    }
}
//输出成果
a除以b等于：0.67

三、`BigDecimal` 常用办法

常用结构办法

常用办法

3.1 加法运算 add

public class BigDecimalDemo {
    public static void main(String[] args) {
       BigDecimal a = new BigDecimal(Double.toString(0.1));
       BigDecimal b = BigDecimal.valueOf(0.2);
        System.out.println("a + b ="+a.add(b));
    }
}
//输出成果
a + b =0.3

3.2 减法运算 subtract

public class BigDecimalDemo {
    public static void main(String[] args) {
       BigDecimal a = new BigDecimal(Double.toString(3.5));
       BigDecimal b = BigDecimal.valueOf(2.1);
        System.out.println("a - b ="+a.subtract(b));
    }
}
//输出成果
a - b =1.4

3.3 乘法运算 multiply

public class BigDecimalDemo {
    public static void main(String[] args) {
       BigDecimal a = new BigDecimal(Double.toString(2.5));
       BigDecimal b = BigDecimal.valueOf(3.26);
        System.out.println("a * b ="+a.multiply(b));
    }
}
//输出成果
a * b =8.150

3.4 除法运算 divide

BigDecimal除法或许呈现不能整除的状况,比方 1.2/1.3，

这时会报错java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

这个之前也说过，这儿呢再详细说说divide 办法

BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

divisor : 表明除数
scale: 表明小数点后保存位数

roundingMode: 表明舍入形式。roundingMode是一个枚举类,有八种舍入形式

咱们以0.333 和-0.333保存2位小数为例，选用不同形式后得成果为

–形式	–形式阐明	图形阐明
`UP`	远离0的舍入形式【0.333–>0.34 -0.333 –>-0.34】
`DOWN`	接近0的舍入形式【0.333–>0.33 -0.333 –>-0.33】
`CEILING`	CEILING英文是天花板的意思，能够理解为向”大“舍入【0.333–>0.34 -0.333 –>-0.33】
`FLOOR`	FLOOR有地板的意思，能够理解为向”小“舍入【0.333–>0.33 -0.333 –>-0.34】
`HALF_UP`	向“最接近的”数字舍入，假如与两个相邻数字的间隔持平，则为向上舍入的舍入其实便是四舍五入【>=0.5 入，<0.5的舍去】
`HALF_DOWN`	向“最接近的”数字舍入，假如与两个相邻数字的间隔持平，则为上舍入的舍入，其实便是五舍六入【>0.5 的入，<=0.5 的舍去】
`HALF_EVEN`	向“最接近的”数字舍入，假如与两个相邻数字的间隔持平，则向相邻的偶数舍入【0.135–>0.14 0.125–>0.12】
`UNNECESSARY`	断语请求的操作具有准确的成果，因此不需要舍入

public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal numA = new BigDecimal("1");
            BigDecimal numB = new BigDecimal("-1");
            BigDecimal numC = new BigDecimal("3");
            // 保存两位小数，舍入形式为UP
            System.out.println("1/3保存两位小数（UP） = " + numA.divide(numC, 2, RoundingMode.UP));
            System.out.println("-1/3保存两位小数（UP） = " + numB.divide(numC, 2, RoundingMode.UP));
            // 保存两位小数，舍入形式为DOWN
            System.out.println("1/3保存两位小数（DOWN） = " + numA.divide(numC, 2, RoundingMode.DOWN));
            System.out.println("-1/3保存两位小数（DOWN） = " + numB.divide(numC, 2, RoundingMode.DOWN));
            // 保存两位小数，舍入形式为CEILING
            System.out.println("1/3保存两位小数（CEILING） = " + numA.divide(numC, 2, RoundingMode.CEILING));
            System.out.println("-1/3保存两位小数（CEILING） = " + numB.divide(numC, 2, RoundingMode.CEILING));
            // 保存两位小数，舍入形式为FLOOR
            System.out.println("1/3保存两位小数（FLOOR） = " + numA.divide(numC, 2, RoundingMode.FLOOR));
            System.out.println("-1/3保存两位小数（FLOOR） = " + numB.divide(numC, 2, RoundingMode.FLOOR));
            BigDecimal numD = new BigDecimal("1");
            BigDecimal numE = new BigDecimal("-1");
            BigDecimal numF = new BigDecimal("8");
            // 保存两位小数，舍入形式为HALF_UP
            System.out.println("1/8(=0.125)保存两位小数（HALF_UP） = " + numD.divide(numF, 2, RoundingMode.HALF_UP));
            System.out.println("-1/8(=0.125)保存两位小数（HALF_UP） = " + numE.divide(numF, 2, RoundingMode.HALF_UP));
            // 保存两位小数，舍入形式为HALF_DOWN
            System.out.println("1/8(=0.125)保存两位小数（HALF_DOWN） = " + numD.divide(numF, 2, RoundingMode.HALF_DOWN));
            System.out.println("-1/8(=0.125)保存两位小数（HALF_DOWN） = " + numE.divide(numF, 2, RoundingMode.HALF_DOWN));
            // 保存两位小数，舍入形式为HALF_EVEN
            System.out.println("0.54/4(=0.135)保存两位小数（HALF_EVEN） = " + new BigDecimal("0.54").divide(new BigDecimal("4"), 2, RoundingMode.HALF_EVEN));
            System.out.println("1/8(=0.125)保存两位小数（HALF_EVEN） = " + numE.divide(numF, 2, RoundingMode.HALF_EVEN));
            //UNNECESSARY,会报反常
            System.out.println("1/8(=0.125) = " + numE.divide(numF,  RoundingMode.UNNECESSARY));
        }
}
//输出成果
1/3保存两位小数（UP） = 0.34
-1/3保存两位小数（UP） = -0.34
1/3保存两位小数（DOWN） = 0.33
-1/3保存两位小数（DOWN） = -0.33
1/3保存两位小数（CEILING） = 0.34
-1/3保存两位小数（CEILING） = -0.33
1/3保存两位小数（FLOOR） = 0.33
-1/3保存两位小数（FLOOR） = -0.34
1/8(=0.125)保存两位小数（HALF_UP） = 0.13
-1/8(=0.125)保存两位小数（HALF_UP） = -0.13
1/8(=0.125)保存两位小数（HALF_DOWN） = 0.12
-1/8(=0.125)保存两位小数（HALF_DOWN） = -0.12
0.54/4(=0.135)保存两位小数（HALF_EVEN） = 0.14
1/8(=0.125)保存两位小数（HALF_EVEN） = -0.12
Exception in thread "main" java.lang.ArithmeticException: Rounding necessary

3.5 值转化

public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal a = new BigDecimal(Double.toString(2.3));
            BigDecimal b = new BigDecimal(10200000);
            System.out.println("BigDecimal转字符串："+a.toString());
            System.out.println("BigDecimal转double："+a.doubleValue());
            System.out.println("BigDecimal转float："+a.floatValue());
            System.out.println("BigDecimal转长整型："+b.longValue());
            System.out.println("BigDecimal转int："+b.intValue());
    }
}
//输出成果
BigDecimal转字符串：2.3
BigDecimal转double：2.3
BigDecimal转float：2.3
BigDecimal转长整型：10200000
BigDecimal转int：10200000

3.6 绝对值 abs

public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal a = new BigDecimal(Double.toString(2.35));
            BigDecimal b = BigDecimal.valueOf(-2.35);
            System.out.println("a的绝对值是：" + a.abs());
            System.out.println("b的绝对值是：" + b.abs());
    }
}
//输出成果
a的绝对值是：2.35
b的绝对值是：2.35

3.7 等值比较

《阿里巴巴Java开发手册》榜首章 1.4 OOP规约中提到

❾**【强制】** 浮点数之间的等值判别，根本数据类型不能用==进行比较，包装数据类型不能用equals办法判别。

阐明：浮点数选用“尾数+阶码”的编码办法，类似于科学计数法的“有用数字+指数“ 的表明办法。

二级制无法准确表明大部分十进制小数，详细原理参考《码出高效，Java开发手册》

反例：
    float a = 1.0f - 0.9f;
    float b = 0.9f - 0.8 f;
	if(a==b){
        //预期进入此代码块，履行其他事务逻辑
        //但事实上a==b 的成果为false
    }
	Float x = Float.valueOf(a);
	Float y = Float.valueOf(b);
	if(x.equals(y)){
        // 预期进入此代码块，履行其他事务逻辑
        //但事实上x.equals(y)的成果为false
    }
正例：
    1）指定一个差错规模，若两个浮点数的差值在此规模之内，则以为是持平的。
    float a = 1.0f - 0.9f;
    float b = 0.9f - 0.8f;
	//10的-6次方
	float diff = 1e-6f;
	if(Math.abs(a-b)<diff){
        System.out.println("true");
    }
	2)运用BigDecimal界说值，再进行浮点数的运算操作。
    BigDecimal a = BigDecimal("0.1");
    BigDecimal b = BigDecimal("0.9");
    BigDecimal c = BigDecimal("0.8");
	BigDecimal x = a.subtract(b);
	BigDecimal y = b.subtract(c);
	/**
	*BigDecimal的等值比较应运用compareTo()办法，而不是equals() 办法。
	*阐明：equals()办法会比较值和精度（1.0 与1.00 回来成果为false）,
	*而compareTo()则会疏忽精度。
	**/
	if (x.compareTo(y)==0){
        System.out.println("true");
    }

等值比较用compareTo(BigDecimal val) 办法

a.compareTo(b)

-1：表明a小于b
0：表明a等于b
1：表明a大于b

public class BigDecimalDemo {
    public static void main(String[] args) {
            BigDecimal a = new BigDecimal("0.5");
            BigDecimal b = new BigDecimal("0.8");
            BigDecimal c = new BigDecimal("0.3");
            BigDecimal d = new BigDecimal("0.5");
            System.out.println("a与b比较成果:"+a.compareTo(b));
            System.out.println("a与c比较成果:"+a.compareTo(c));
            System.out.println("a与d比较成果:"+a.compareTo(d));
    }
}
//输出成果
a与b比较成果:-1
a与c比较成果:1
a与d比较成果:0

四、`BigDecimal`格式化

NumberFormat类的format()办法能够运用BigDecimal目标作为参数，

能够对超出16位有用数字的钱银值，百分值，以及一般数值进行格式化控制

public class BigDecimalDemo {
    public static void main(String[] args) {
            NumberFormat money = NumberFormat.getCurrencyInstance(); //树立钱银格式化引证
            NumberFormat percent = NumberFormat.getPercentInstance();  //树立百分比格式化引证
            percent.setMaximumFractionDigits(3); //百分比小数点最多3位
            BigDecimal loanAmount = new BigDecimal("15000.48"); //借款金额
            BigDecimal interestRate = new BigDecimal("0.008"); //利率
            BigDecimal interest = loanAmount.multiply(interestRate); //相乘
            System.out.println("借款金额:" + money.format(loanAmount));
            System.out.println("利率:" + percent.format(interestRate));
            System.out.println("利息:" + money.format(interest));
    }
}
//输出成果
借款金额:￥15,000.48
利率:0.8%
利息:￥120.00

五、`BigDecimal` 东西类

为了愈加方便的运用BigDecimal 咱们能够将其常用办法封装成东西类

package com.xiezhr.util;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
 * 简化BigDecimal核算的小东西类
 */
public class BigDecimalUtil {
    /**
     * 默认除法运算精度
     */
    private static final int DEF_DIV_SCALE = 10;
    private BigDecimalUtil() {
    }
    /**
     * 供给准确的加法运算。
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.add(b2).doubleValue();
    }
    /**
     * 供给准确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.subtract(b2).doubleValue();
    }
    /**
     * 供给准确的乘法运算。
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.multiply(b2).doubleValue();
    }
    /**
     * 供给（相对）准确的除法运算，当发生除不尽的状况时，准确到
     * 小数点以后10位，以后的数字四舍五入。
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2) {
        return divide(v1, v2, DEF_DIV_SCALE);
    }
    /**
     * 供给（相对）准确的除法运算。当发生除不尽的状况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表明表明需要准确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
    }
    /**
     * 供给准确的小数位四舍五入处理。
     *
     * @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 = BigDecimal.valueOf(v);
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
    }
    /**
     * 供给准确的类型转化(Float)
     *
     * @param v 需要被转化的数字
     * @return 回来转化成果
     */
    public static float convertToFloat(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.floatValue();
    }
    /**
     * 供给准确的类型转化(Int)不进行四舍五入
     *
     * @param v 需要被转化的数字
     * @return 回来转化成果
     */
    public static int convertsToInt(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.intValue();
    }
    /**
     * 供给准确的类型转化(Long)
     *
     * @param v 需要被转化的数字
     * @return 回来转化成果
     */
    public static long convertsToLong(double v) {
        BigDecimal b = new BigDecimal(v);
        return b.longValue();
    }
    /**
     * 回来两个数中大的一个值
     *
     * @param v1 需要被比照的榜首个数
     * @param v2 需要被比照的第二个数
     * @return 回来两个数中大的一个值
     */
    public static double returnMax(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.max(b2).doubleValue();
    }
    /**
     * 回来两个数中小的一个值
     *
     * @param v1 需要被比照的榜首个数
     * @param v2 需要被比照的第二个数
     * @return 回来两个数中小的一个值
     */
    public static double returnMin(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.min(b2).doubleValue();
    }
    /**
     * 准确比照两个数字
     *
     * @param v1 需要被比照的榜首个数
     * @param v2 需要被比照的第二个数
     * @return 假如两个数一样则回来0，假如榜首个数比第二个数大则回来1，反之回来-1
     */
    public static int compareTo(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.compareTo(b2);
    }
}

六、避坑小结

商业核算运用BigDecimal
尽量运用参数类型为String的结构函数
BigDecimal都是不可变的，在进行每一步运算时，都会发生一个新的目标，所以在做加减乘除运算时千万要保存操作后的值

经过本期内容，你还会掉金钱圈套里么？

本期内容到此就结束了，咱们下期再见。(●’◡’●)

Java中的金钱陷阱

前言

一、存在的圈套

1.1 浮点运算精度丢掉圈套

1.2 浮点数等值判别圈套

1.3 `BigDecimal` 结构办法中的圈套

1.4 `BigDecimal` 除法圈套

二、避免圈套

2.1 浮点数运算避坑

2.2 浮点数等值判别避坑

2.3 `BigDecimal` 结构办法避坑

2.4 `BigDecimal` 除法避坑

三、`BigDecimal` 常用办法

3.1 加法运算 add

3.2 减法运算 subtract

3.3 乘法运算 multiply

3.4 除法运算 divide

3.5 值转化

3.6 绝对值 abs

3.7 等值比较

四、`BigDecimal`格式化

五、`BigDecimal` 东西类

六、避坑小结

作者信息

推广

Java中的金钱陷阱

前言

一 、 存在的圈套

1.1 浮点运算精度丢掉圈套

1.2 浮点数等值判别圈套

1.3 BigDecimal 结构办法中的圈套

1.4 BigDecimal 除法圈套

二、避免圈套

2.1 浮点数运算避坑

2.2 浮点数等值判别避坑

2.3 BigDecimal 结构办法避坑

2.4 BigDecimal 除法避坑

三、BigDecimal 常用办法

3.1 加法运算 add

3.2 减法运算 subtract

3.3 乘法运算 multiply

3.4 除法运算 divide

3.5 值转化

3.6 绝对值 abs

3.7 等值比较

四、BigDecimal格式化

五、BigDecimal 东西类

六、避坑小结

相关文章

C/C++ 恨透了 double free or corruption

专注效率提升「GitHub 热点速览 v.22.36」

从 NASL 说开：低代码编程语言能饭否

探究新技术的本质与制造业数字化转型趋势

作者信息

推广

一、存在的圈套

1.3 `BigDecimal` 结构办法中的圈套

1.4 `BigDecimal` 除法圈套

2.3 `BigDecimal` 结构办法避坑

2.4 `BigDecimal` 除法避坑

三、`BigDecimal` 常用办法

四、`BigDecimal`格式化

五、`BigDecimal` 东西类