Java中的金钱陷阱 - xiezhr - JOYK Joy of Geek, Geek News, Link all geek

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

但是我们说的不是过度追求金钱而掉入陷阱，而是要说一说在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中的金钱陷阱 - xiezhr

一、存在的陷阱

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` 工具类

六、避坑小结

Recommend

Tether Enters El Salvador's Sustainable Crypto Mining Powered by Volcanic Energy...

Scaling audio-visual learning without labels

北辰饲料获得1000万元新三板定增融资

苹果放出 Xcode 15 Beta 1 更新：体积减半，效率翻倍

Coinbase suit, Molson Coors upgrade, Boeing Dreamliner woes: Top tickers

AMD AI芯片MI300 Q4有望贡献2亿美元营收

Rust Binary Analysis, Feature by Feature

英特尔猛兽峡谷 NUC 主机降至 4299 元：8 大核 i7-11700B 准系统

Criminalization of encryption : the 8 december case – La Quadrature du Net

湖南启动治理教育乱收费专项检查，聚焦大中专院校学历教育收费等

About Joyk

Java中的金钱陷阱 - xiezhr

一 、 存在的陷阱

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 工具类

六、避坑小结

Recommend

About Joyk

一、存在的陷阱

1.3 `BigDecimal` 构造方法中的陷阱

1.4 `BigDecimal` 除法陷阱

2.3 `BigDecimal` 构造方法避坑

2.4 `BigDecimal` 除法避坑

三、`BigDecimal` 常用方法

四、`BigDecimal`格式化

五、`BigDecimal` 工具类