Java: Check if two double values match on specific no of decimal places

Compari开发者_运维知识库ng those two values shall result in a "true":

53.9173333333333  53.9173

If you want a = 1.00001 and b = 0.99999 be identified as equal:

return Math.abs(a - b) < 1e-4;

Otherwise, if you want a = 1.00010 and b = 1.00019 be identified as equal, and both a and b are positive and not huge:

return Math.floor(a * 10000) == Math.floor(b * 10000);
// compare by == is fine here because both sides are integral values.
// double can represent integral values below 2**53 exactly.

Otherwise, use the truncate method as shown in Are there any functions for truncating a double in java?:

BigDecimal aa = new BigDecimal(a);
BigDecimal bb = new BigDecimal(b);
aa = aa.setScale(4, BigDecimal.ROUND_DOWN);
bb = bb.setScale(4, BigDecimal.ROUND_DOWN);
return aa.equals(bb);

here is the simple example if you still need this :)

public static boolean areEqualByThreeDecimalPlaces(double a, double b) {

    a = a * 1000;

    b = b * 1000;

    int a1 = (int) a;

    int b1 = (int) b;

    if (a1 == b1) {
        System.out.println("it works");
        return true;
    }

    else
        System.out.println("it doesn't work");
    return false;

Naively:

if(Math.abs(a-b) < 0.0001)

However, that's not going to work correctly for all values. It's actually impossible to get it to work as long as you're using double, because double is implemented as binary fractons and does not even have decimal places.

You'll have to convert your values to String or BigDecimal to make meaningful tests about their decimal places.

You may want to read the Floating-Point Guide to improve your understanding of how floating point values work.

Apache commons has this: org.apache.commons.math3.util.Precision equals(double x, double y, double eps)

epsilon would be the distance you would allow. Looks like yours would be 1e-5?

The source-code of this method looks like it uses Math.abs as suggested in other answers.

public static boolean areEqualByThreeDecimalPlaces(double a, double b){
    if(a < 0 && b < 0) {
        double c = Math.ceil(a * 1000) / 1000;
        double d = Math.ceil(b * 1000) / 1000;
        return c == d;
    }
    if(a > 0 && b > 0){
        double c = Math.floor(a * 1000) / 1000;
        double d = Math.floor(b * 1000) / 1000;
        return c == d;
    }
    return a == b;
}

Thanks. I did it this way:

double lon = 23.567889;
BigDecimal bdLon = new BigDecimal(lon);
bdLon = bdLon.setScale(4, BigDecimal.ROUND_HALF_UP);

System.out.println(bdLon.doubleValue());

public static boolean areEqualByThreeDecimalPlaces(double a, double b) {

if(a > 0 && b >0){
    return ((int)Math.floor(a * 1000) == (int)Math.floor(b * 1000));
}
else if (a < 0 && b <0) {
    return ((int)Math.ceil(a * 1000) == (int)Math.ceil(b * 1000));
}

return a==b;
}

public static boolean areEqualBySixDecimalPlaces(double a, double b) {
        int num1 = (int) (a * 1e6);
        int num2 = (int) (b * 1e6);
        return num1 == num2;
    }

Casting up to desired digits shall be the simplest solution if you know the values

The solution to compare two double-digits up to three decimal places and return true or false might be:

public static boolean areEqualByThreeDecimalPlaces(double myFirstNumber , double mySecondNumber){
    if (Math.abs(myFirstNumber - mySecondNumber) < 0.0009 ){
        return true;
    } else {
        return false;
    }
}