比较浮点型数据大小（Double 包装类）& BigDecimal 入参为 double 时精度处理

public class DoubleExample {
 
    public static void main(String[] args) {

        // compares two Double objects numerically
        Double d1 = new Double("0.05");
        Double d2 = new Double("0.05000");
        int ret =  d1.compareTo(d2);

        if(ret > 0) { // 大于被比的浮点数
            System.out.println("d1: " + d1 + " is greater than d2: "  + d2);
        }
        else if(ret < 0) { // 小于被比的浮点数
            System.out.println("d1: " + d1 + " is less than d2: " + d2);
        }
        else { // 相等
            System.out.println("d1: " + d1 + " is equal to d2: " + d2);
        }
    }
}

直接以浮点型数据给BigDecimal赋值的话会有精度问题！

可使用String，入参为String的构造方法，或使用BigDecimal的静态方法valueOf，此方法内部其实执行了Double的toString，而Double的toString按double的实际能表达的精度对尾数进行了截断。

    public static void main(String[] args) {
        double d = 0.9D;
        BigDecimal a = new BigDecimal(String.valueOf(d));
        BigDecimal b = new BigDecimal("0.9");
        BigDecimal c = new BigDecimal(Double.valueOf(d).toString());
        BigDecimal bigDecimal = BigDecimal.valueOf(d);
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(bigDecimal);
    }

 

 

大于

等于

小于

封装类DOUBLE的比较底层实现

    /**
     * Compares the two specified {@code double} values. The sign
     * of the integer value returned is the same as that of the
     * integer that would be returned by the call:
     * <pre>
     *    new Double(d1).compareTo(new Double(d2))
     * </pre>
     *
     * @param   d1        the first {@code double} to compare
     * @param   d2        the second {@code double} to compare
     * @return  the value {@code 0} if {@code d1} is
     *          numerically equal to {@code d2}; a value less than
     *          {@code 0} if {@code d1} is numerically less than
     *          {@code d2}; and a value greater than {@code 0}
     *          if {@code d1} is numerically greater than
     *          {@code d2}.
     * @since 1.4
     */
    public static int compare(double d1, double d2) {
        if (d1 < d2)
            return -1;           // Neither val is NaN, thisVal is smaller
        if (d1 > d2)
            return 1;            // Neither val is NaN, thisVal is larger

        // Cannot use doubleToRawLongBits because of possibility of NaNs.
        long thisBits    = Double.doubleToLongBits(d1);
        long anotherBits = Double.doubleToLongBits(d2);

        return (thisBits == anotherBits ?  0 : // Values are equal
                (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
                 1));                          // (0.0, -0.0) or (NaN, !NaN)
    }

    /**
     * Returns a representation of the specified floating-point value
     * according to the IEEE 754 floating-point "double
     * format" bit layout.
     *
     * <p>Bit 63 (the bit that is selected by the mask
     * {@code 0x8000000000000000L}) represents the sign of the
     * floating-point number. Bits
     * 62-52 (the bits that are selected by the mask
     * {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0
     * (the bits that are selected by the mask
     * {@code 0x000fffffffffffffL}) represent the significand
     * (sometimes called the mantissa) of the floating-point number.
     *
     * <p>If the argument is positive infinity, the result is
     * {@code 0x7ff0000000000000L}.
     *
     * <p>If the argument is negative infinity, the result is
     * {@code 0xfff0000000000000L}.
     *
     * <p>If the argument is NaN, the result is
     * {@code 0x7ff8000000000000L}.
     *
     * <p>In all cases, the result is a {@code long} integer that, when
     * given to the {@link #longBitsToDouble(long)} method, will produce a
     * floating-point value the same as the argument to
     * {@code doubleToLongBits} (except all NaN values are
     * collapsed to a single "canonical" NaN value).
     *
     * @param   value   a {@code double} precision floating-point number.
     * @return the bits that represent the floating-point number.
     */
    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;
    }

本地方法实现double的精度处理！！！