1.5 Casting and Range of Variables

1. The casting operators

The 2 casting operators are (int) and (double). They convert a double value to an int value, or an int value to a double value 1.5.A.1. Casting a double to an int causes the digits to the right of the decimal point to be truncated (cut off) 1.5.A.2. Truncating moves toward zero, for negative numbers too.

A cast is a one-operand operator, so it applies only to the value right after it (see the precedence table in topic 1.3).

Code	Result	Rule
(int) 3.86	3	casting to int truncates (cuts off) the decimal part
(int) -3.86	-3	truncating moves toward zero for negatives too
(double) 7 / 2	3.5	the cast happens first, so this is 7.0 / 2
(double) (7 / 2)	3.0	7 / 2 is already 3 before the cast
double d = 7;	7.0	an int is automatically cast (widened) to double
(int) (3.86 + 0.5)	4	rounds a non-negative double to the nearest int
(int) (-3.86 - 0.5)	-4	rounds a negative double to the nearest int

System.out.println((int) 3.86);
System.out.println((int) -3.86);
System.out.println((double) 7 / 2);
System.out.println((double) (7 / 2));
double d = 7;
System.out.println(d);
System.out.println((int) (3.86 + 0.5));
System.out.println((int) (-3.86 - 0.5));

Output:

3
-3
3.5
3.0
7.0
4
-4

2. Widening: int to double automatically

Some code causes int values to be automatically cast (widened) to double values 1.5.A.3. This happens when you store an int in a double variable, or when an int meets a double in an expression.

int steps = 7;
double km = steps;          // widened to 7.0
System.out.println(km);
System.out.println(steps * 1.5);

Output:

7.0
10.5

The other direction is never automatic, because it could lose information. A double cannot be stored in an int variable without a cast:

// does not compile
int k = 3.5;

Real view:

error: incompatible types: possible lossy conversion from double to int

int k = (int) 3.5; compiles and stores 3.

3. Rounding to the nearest integer

Values of type double can be rounded to the nearest integer with (int) (x + 0.5) for non-negative numbers or (int) (x - 0.5) for negative numbers 1.5.A.4.

double rating = 4.7;
double drop = -2.6;
System.out.println((int) rating);
System.out.println((int) (rating + 0.5));
System.out.println((int) (drop - 0.5));

Output:

4
5
-3

Watch out: the parentheses matter. (int) rating + 0.5 casts first, giving 4 + 0.5, which is the double 4.5.

4. The range of int and integer overflow

The constant Integer.MAX_VALUE holds the largest possible int value, and Integer.MIN_VALUE holds the smallest 1.5.B.1. An int is stored in a fixed amount of memory (4 bytes), so every int value must lie in the range from Integer.MIN_VALUE (-2147483648) to Integer.MAX_VALUE (2147483647), inclusive 1.5.B.2.

If an expression would evaluate to an int outside this range, integer overflow occurs. The result is still an int in the allowed range, but not necessarily the value you expected 1.5.B.3. No error is reported; the program keeps running with the wrong value.

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

Output:

2147483647
-2147483648
-2147483647
-2147483648

5. Round-off error with double

Computers give each data type a fixed amount of memory. A double also has limited memory. When an expression would produce a double that is more precise than can be stored, a round-off error occurs, and the result is rounded to the nearest representable value. To avoid these rounding errors, use int values where you can, for example by storing money in cents 1.5.C.1.

System.out.println(0.1 + 0.2);
int cents = 10 + 20;
System.out.println(cents + " cents");

Output:

0.30000000000000004
30 cents

Outside the course: other special decimal types that avoid rounding errors.

Background (not tested): why 0.1 is not exact. Computers store numbers in binary (base 2). Just as 1/3 never ends in decimal (0.333…), 1/10 never ends in binary, so a double holds a value very close to 0.1, not exactly 0.1. Tiny errors like this are why you should not test double values with == (Unit 2).