Basically, I don't understand why the code below will output 434 when 4.35 * 100 = 435.0 which is converted to the int of 435, right?
What is the simple explanation for this and is this an issue which crops up often?
How would you get around this?
public class RoundOffDemo {
public static void main(String[] args) {
double price = 4.35;
int cents = (int) (100 * price); // Should be 435
System.out.println(cents); // Prints 434!
}
}
The problem is that 4.35 cannot be exactly represented in binary. So 4.35 * 100 is not exactly 435.0. (Every fraction in binary is the sum of inverse powers of 2, all of which are terminating decimals. Unfortunately, 0.35 decimal has a non-terminating binary expansion. So 4.35 is more like 4.349999...x (where x is something beyond which everything is zero, courtesy of the machine's finite representation of floating point numbers.) Integer truncation then produces 434. You can use Math.round() to avoid this problem.
float so round returns an int. (Although, for the numbers OP is using, using float to start with instead of double might be the best option.)
IMO, the suggestions to use a BigDecimal are overkill. For cents, use a long. Even the US National Debt can be covered using a long for cents.
If you do use floats (or doubles), when converting to integers, use Math.round(), Math.floor() or Math.ceil() as appropriate.
if you use this code:
System.out.println(price*100); // Prints 434!
you notice its output is
434.99999999999994
which rounded is 434
Double value 4.35 is actually represented as 4.349999999999999. 100 * 4.349999999999999 = 434.9999999999999. And casting it to int value will give you 434.
This is a result of floating point arithmetic. The (int) casting is not a rounding function, but rather a truncation as @Ted points out.
Since you are dealing with money ( as evident from your variable names ) use BigDecimal instead.
For example --
double d = 4.35;
BigDecimal bd = BigDecimal.valueOf(d);
bd = bd.multiply(new BigDecimal(100));
d is already not 4.35 exactly, so bd just carries this rounding error forward.
BigDecimal.valueOf(d) uses Double.toString(d) and consistently produces the same output. Am I making an assumption I shouldn't here?Do not use double/float for floating-point arithmetic in Java, use BigDecimal instead. This is because Java cannot represent floating-point precisely.
Always use BigDecimal for temporary variables, which will be processed/involved in future calculations. Convert the values to float/double only if you want to persist them into the database.
