Lesson 1.5 · Unit 1 · CED topic 1.5

Casting and the range of variables

Java keeps int and double apart on purpose, but real programs mix them all the time: an average of whole numbers, a price rounded to cents, a percentage of a count. This lesson covers the tool that converts between them, the cast, and the two ways numbers can quietly go wrong: values that fall out of an int's range and values a double cannot hold exactly.

Casting with (int) and (double)

A casting operator converts a value to another type. The two you need are (int) and (double), written in parentheses directly before the value.

• (int) on a double truncates: the digits to the right of the decimal point are dropped, with no rounding. (int) 3.99 is 3, and (int) -3.99 is -3, because truncation always moves toward zero.
• (double) on an int produces the same number with a decimal part: (double) 4 is 4.0.
• Some code casts automatically. An int used where a double is needed is widened to a double without a cast, which is why double x = 7; is legal and stores 7.0.

System.out.println((int) 3.99);
System.out.println((int) -3.99);
System.out.println((double) 4);
double widened = 7;
System.out.println(widened);

3
-3
4.0
7.0

### A cast binds tightly

A cast applies to the value immediately after it, before any arithmetic operator runs. That makes the position of the parentheses matter.

The second pair is the most useful pattern in the course. To compute an average of int values without losing the fraction, cast one operand before the division:

int sum = 17;
int count = 4;
System.out.println(sum / count);
System.out.println((double) sum / count);
System.out.println((double) (sum / count));

4
4.25
4.0

### Rounding to the nearest integer

A cast truncates, so to round you first nudge the value. For a non-negative x, (int) (x + 0.5) gives the nearest integer. For a negative x, (int) (x - 0.5) does. To round to a number of decimal places, scale up, round, and scale back down:

double price = 12.3456;
int nearestDollar = (int) (price + 0.5);
double nearestCent = (int) (price * 100 + 0.5) / 100.0;
System.out.println(nearestDollar);
System.out.println(nearestCent);

12
12.35

The range of an int

Integers in Java are stored in a fixed amount of memory (4 bytes), so an int can only hold values between two limits. Two constants name them.

If an expression would produce an int outside that range, integer overflow occurs. Java does not stop and does not warn. The result is an int that is in the allowed range but not the value you expected, because the value wraps around.

int big = Integer.MAX_VALUE;
System.out.println(big);
System.out.println(big + 1);

2147483647
-2147483648

When a double is not exact

A double also lives in a fixed amount of memory. Many decimal numbers, such as 0.1, have no exact binary representation, so the stored value is the nearest one that fits. Arithmetic on these values can produce a round-off error.

System.out.println(0.1 + 0.2);
System.out.println(0.1 + 0.2 == 0.3);

0.30000000000000004
false

The rule that follows: do not rely on exact equality of computed double values, and when exactness matters, use int values. A program that tracks money in whole cents with an int never accumulates this error.

int a = 9;
int b = 4;
double d = 2.5;
System.out.println(a / b);
System.out.println((double) a / b);
System.out.println((int) d * 3);
System.out.println((int) (d * 3));
System.out.println((int) (d + 0.5));

2
2.25
6
7
3

int s1 = 90;
int s2 = 85;
int s3 = 90;
double wrong = (s1 + s2 + s3) / 3;
double right = (s1 + s2 + s3) / 3.0;
System.out.println(wrong);
System.out.println(right);

88.0
88.33333333333333

double dollars = 1.10 + 2.20;
int cents = 110 + 220;
System.out.println(dollars);
System.out.println(cents / 100 + " dollars and " + cents % 100 + " cents");

3.3000000000000003
3 dollars and 30 cents