How Can I Safely Compare Double Values in Java to Avoid Precision Errors?

The Precision Hazard of Double Comparison in Java and Its Resolution

Comparing double values in Java can be a deceptive task. A naive comparison, as illustrated below, may yield unexpected results due to floating-point precision limitations:

double a = 1.000001;
double b = 0.000001;

if ((a-b) == 1.0) {
  // This condition evaluates to false, though it seemingly should be true.
}

The issue arises because the subtraction a-b does not return exactly 1.0, but a value very close to it. Floating-point arithmetic can introduce rounding errors, resulting in a value of 0.9999999999999999, which is not equal to 1.0.

To avoid this pitfall, it is recommended to use an approximate comparison instead of an exact one. The Math.abs() method can be employed to calculate the absolute difference between the actual result and the expected value, and this difference can be compared to a small tolerance value:

double c = a-b;
if (Math.abs(c-1.0) <= 0.000001) {
  // This condition evaluates to true, as the absolute difference is small enough.
}

By setting an appropriate tolerance value, you can control the level of precision acceptable for the comparison. This approach allows you to handle floating-point precision limitations effectively and ensure accurate evaluations.

The above is the detailed content of How Can I Safely Compare Double Values in Java to Avoid Precision Errors?. For more information, please follow other related articles on the PHP Chinese website!