解决double的值相加的问题

public class DoubleCaculator {
    double price = 0.38;
    int count = 3;
    
    @Test
    public void demo1() {
        //结果：1.1400000000000001
        System.out.println(price * count);
    }
}

    @Test
    public void demo2() {
        //bigDecimal的字符串的构造完美解决了double计算的问题
        BigDecimal bdP = new BigDecimal(price);
        BigDecimal bdc = new BigDecimal(count);
        BigDecimal add = bdP.multiply(bdc);
        System.out.println(add.doubleValue());
    }

The results of this constructor can be somewhat unpredictable.
     * One might assume that writing {@code new BigDecimal(0.1)} in
     * Java creates a {@code BigDecimal} which is exactly equal to
     * 0.1 (an unscaled value of 1, with a scale of 1), but it is
     * actually equal to
     * 0.1000000000000000055511151231257827021181583404541015625.
     * This is because 0.1 cannot be represented exactly as a
     * {@code double} (or, for that matter, as a binary fraction of
     * any finite length).  Thus, the value that is being passed
     * <i>in</i> to the constructor is not exactly equal to 0.1,
     * appearances notwithstanding.
     *

The {@code String} constructor, on the other hand, is
     * perfectly predictable: writing {@code new BigDecimal("0.1")}
     * creates a {@code BigDecimal} which is <i>exactly</i> equal to
     * 0.1, as one would expect.  Therefore, it is generally
     * recommended that the {@linkplain #BigDecimal(String)
     * <tt>String</tt> constructor} be used in preference to this one.
     *

    @Test
    public void demo2() {
        //bigDecimal的字符串的构造完美解决了double计算的问题
        BigDecimal bdP = new BigDecimal(price + "");
        BigDecimal bdc = new BigDecimal(count + "");
        BigDecimal add = bdP.multiply(bdc);
        System.out.println(add.doubleValue());
    }