If you have been doing Java programming then you may know that the use of == operator is not the correct way to compare floating point values in Java. If you use equality operator to compare float and double variables then it can cause an endless loop in Java, but is there a way to prevent that loop from running infinitely? Yes, instead of using == operator, you can use relational operator e.g. less than (<) or greater than (>) to compare float and double values.

By changing the above code as following, you can prevent the loop from infinitelyΒ :

```
for(double balance = 10; balance > 0; balance-=0.1) {\
Β Β System.out.println(balance);\
}
```

If you think little bit than you will realize that greater than will definitely end this loop, but don't expect it to print numbers like 9.9, 9.8, 9.7 because floating point numbers are just approximation, they are not exact. Some numbers e.g. 1/3 cannot be represented exactly using float and double in Java.

After running following program in your computer you may end up with something like this

## Java ProgramΒ to compare float and double values:

Here is the complete Java program to check if two float or double values are equal, greater or less than of each other.

```
public class FloatComparator {
public static void main(String args[]){
float firstValue = 10.2f;
float secondValue = 10.3f;
float thirdValue = 10.2f;
if(firstValue > secondValue){
System.out.print("First Value and second value are not equal");
}
}
}
```

Β

By the way, this is not the only way, you can also use equals() method of Wrapper classes like Float and Double to do the floating point comparison. They are in fact preferred way if you want to check if two floating point values are equal or not but if you just want to know that they are not equal then using < and > operator is rather easy.

That's all about right way to compare float and double values in loop in Java. This simple trick of using logical operator less than and greater than instead of equality operator to compare float and double variable can save you a lot of headache.

## Top comments (2)

You are correct that using

`==`

to compare floating-point numbers in Java is almost always problematic. However, you mistakenly suggest using the`equals`

method of the wrapper classes`Double`

or`Float`

as an alternative. That has the same issue. If the floating-point values you are comparing are the results of calculations, there is risk of rounding errors causing values that should be considered equal to be different. The`equals`

method of the wrapper classes just compare the wrapped primitive values with`==`

so it has the same issue.Your suggestion of using

`<`

or`>`

is appropriate in many cases such as your loop example. But not so much in others. Even in that example, due to potential of rounding error in the decrement by`0.1`

, it is not entirely clear without running whether the last iteration will give you something around 0.1 or around 0.0 such as 0.000000000000002. It depends on which side of 0.0 the last result lies.In other cases you may need to know if 2 doubles are sufficiently equal. The

`>`

doesn't help at all. If condition is false, it doesn't mean they are equal.Here is how to actually compare 2 floating-point values for "equality":

You then use a small value for

`epsilon`

. How small depends on situation.`1E-10`

should be fine in many cases. So you can use the above like:Going back to your loop example, you can fix the issue of which iteration is actually last using a similar trick.

If you want to exclude the approximately 0 case, then do:

I used a larger epsilon this time based on the scale of your numbers. We also don't need the

`Math.abs`

this time. You'll need to modify this a bit if you want to include the approximately 0 case.Thanks, looks like still a lot to learn :-)