Casting and Range of Variables

Real programs mix whole numbers and decimals all the time. A runner counts laps as whole numbers, but each lap is 0.25 miles. A shop stores a price of 5 dollars, but wants it in a variable that could later hold 4.99. So far you have kept int values and double values apart. This chapter is about moving a value from one type to the other, and about the limits of each type.

Start with the easy direction. Every whole number is also a number that could have a decimal part: 5 is the same amount as 5.0. Turning 5 into 5.0 loses nothing. Because nothing can go wrong, Java does this conversion for you, without being asked. This automatic conversion from int to double is called widening: the value moves into a “wider” type that can hold everything the narrower one can, and more.

Widening happens in two places you already know.

1. Assignment. When you store an int value in a double variable, Java widens the value first. This is what makes an int value compatible with a double variable, in the sense of Topic 1.4’s rule that a stored value must have a compatible type.
2. Arithmetic with one of each. Topic 1.3 said that an operation with at least one double gives a double. Now you can see how: Java widens the int operand to a double, then does the operation on two double values.

int wholePrice = 5;
double price = wholePrice;
System.out.println(wholePrice);
System.out.println(price);

5
5.0

Now change the situation: instead of an assignment, the int is one operand of an arithmetic operation.

int laps = 7;
double lapLength = 0.25;
double distance = laps * lapLength;
System.out.println(distance);
System.out.println(laps / 2);
System.out.println(laps / 2.0);

1.75
3
3.5

Lines 5 and 6 differ by one character, but that character decides whether widening happens, and widening decides which kind of division Java does.

Widening happens one operation at a time, not for a whole line at once. Java looks at each operator and its two operands, in the order Topic 1.3 described.

System.out.println(7 / 2 * 1.0);
System.out.println(7 * 1.0 / 2);

3.0
3.5

In the first line, 7 / 2 is done first, and both operands are int, so the result is 3. Only then does 3 * 1.0 widen 3 to 3.0. The decimal part was already gone before any double appeared. In the second line, 7 * 1.0 is done first and gives 7.0, so the division 7.0 / 2 keeps its decimal part: 3.5.

public class NoAutoNarrow
{
    public static void main(String[] args)
    {
        double raceLength = 26.2;
        int miles = raceLength;
        System.out.println(miles);
    }
}

NoAutoNarrow.java:6: error: incompatible types: possible lossy conversion from double to int

double average = 12;
double total = 4 * 2.5;
int score = 7 / 2;
System.out.println(average);
System.out.println(total);
System.out.println(score);

12.0
10.0
3

public class WholeDoubleToInt
{
    public static void main(String[] args)
    {
        int count = 12.0;
        System.out.println(count);
    }
}

System.out.println(9 / 4 * 2.0);
System.out.println(9 * 2.0 / 4);

4.0
4.5

Sometimes you really do want only the whole-number part of a double. A race of 26.2 miles counts as 26 complete miles. A trip of 2.25 hours includes 2 full hours. As the last Watch Out showed, Java will not drop the decimal part on its own, because that might be an accident. You need a way to tell the compiler, “I know part of the value will be lost, and I want that.”

That instruction is a cast. A cast converts a value to a different type. You write the type you want in parentheses directly in front of the value:

(int) raceLength

• (int) is the casting operator. The parentheses and the type name together form the operator; the type in the middle says what to convert to.
• raceLength is the value being converted. The cast produces a new int value. It does not change the variable raceLength, which is still a double.

When the cast turns a double into an int, Java truncates the value: it chops off every digit after the decimal point and keeps the whole-number part. It does not round. 26.2 becomes 26, and 26.9 also becomes 26.

double raceLength = 26.2;
int miles = (int) raceLength;
System.out.println(raceLength);
System.out.println(miles);

26.2
26

Now vary the values, including negative ones. Truncating means “drop the decimal part,” so the result always moves toward zero.

System.out.println((int) 7.99);
System.out.println((int) -7.99);
System.out.println((int) 0.6);
System.out.println((int) -0.6);

7
-7
0
0

Look closely at -7.99. On a number line, the whole number just below −7.99 is −8, but truncation does not go “down”; it just erases the decimal digits, leaving −7. A good way to remember it: for positive numbers truncation goes down, for negative numbers it goes up, and either way it goes toward zero.

double average = 89.9;
int grade = (int) average;
System.out.println(grade);

89

System.out.println((int) 12.5);
System.out.println((int) -3.2);
System.out.println((int) 0.999);

12
-3
0

public class HoursWrong
{
    public static void main(String[] args)
    {
        int minutes = 135;
        int wholeHours = minutes / 60.0;
        System.out.println(wholeHours);
    }
}

int minutes = 135;
int wholeHours = (int) (minutes / 60.0);
System.out.println(wholeHours);

2

A teacher stores three quiz scores whose total is 256 points. Both the total and the count are whole numbers, so they are naturally int values. But the average is not a whole number, and Topic 1.3’s rule gets in the way:

int total = 256;
int count = 3;
System.out.println(total / count);

85

Both operands are int, so / keeps only the whole-number part and the .333… is lost. Widening will not help by itself, because widening only happens when a double is already part of the operation. You need to turn one of the int values into a double before the division happens.

The cast (double) does exactly that. It works like (int), but in the other direction: (double) total produces the double version of total’s value, 256.0. Nothing is lost, so the result is the same number with a decimal type. No double is around to cause widening, so you ask for the conversion yourself.

To use a cast correctly, you need one more rule: a cast applies only to the value immediately after it. Java does a cast before *, /, %, +, and -. To cast the result of a whole expression, put the expression in parentheses.

int total = 256;
int count = 3;
double average = (double) total / count;
System.out.println(average);
System.out.println(total);

85.33333333333333
256

int total = 256;
int count = 3;
System.out.println(total / (double) count);

85.33333333333333

Now change one thing: move the cast so it is outside parentheses around the division.

int total = 256;
int count = 3;
double tooLate = (double) (total / count);
double noCast = total / count;
System.out.println(tooLate);
System.out.println(noCast);

85.0
85.0

In (double) (total / count), the parentheses make Java divide first. 256 / 3 divides two int values and gives 85. Then the cast turns 85 into 85.0. The decimal part was thrown away by the division, and casting afterward cannot bring it back. The second line, with no cast at all, does the same thing: total / count is 85, and widening during the assignment turns it into 85.0.

int a = 5;
int b = 2;
System.out.println((double) (a / b));
System.out.println((double) a / b);
System.out.println((int) (a / 2.0));
System.out.println(a / b * 1.0);

2.0
2.5
2
2.0

Back to the grade of 89.9 from 1.5.2. Truncating gives 89, but 89.9 is much closer to 90. Rounding to the nearest whole number is something programs need constantly: scores, distances, temperatures. Java’s (int) only truncates, so the trick is to adjust the value before truncating so that truncation lands on the nearest whole number.

Think about which values should round up to 4: everything from 3.5 up to (but not including) 4.5. If you add 0.5 to each of those, you get values from 4.0 up to 5.0, and truncating any of them gives 4. Values from 3.0 up to 3.5 become 3.5 up to 4.0 after adding 0.5, and truncate to 3. Adding 0.5 shifts the “halfway point” onto a whole number, so truncation does the rest.

For a nonnegative double x (zero or positive), the nearest whole number is:

(int) (x + 0.5)

The parentheses matter: they make Java add 0.5 first and cast the sum. Without them, the cast would apply to x alone (the rule from 1.5.3).

For a negative x, the shift goes the other way. Truncating moves negative numbers up toward zero, so you subtract 0.5 first:

(int) (x - 0.5)

double distance = 3.7;
System.out.println((int) (distance + 0.5));
distance = 3.2;
System.out.println((int) (distance + 0.5));
distance = 2.5;
System.out.println((int) (distance + 0.5));

4
3
3

Now change the sign. A stock price falls by 2.7 dollars, written as -2.7, and you want the nearest whole number of dollars, which is −3.

double change = -2.7;
System.out.println((int) (change + 0.5));
System.out.println((int) (change - 0.5));
change = -2.2;
System.out.println((int) (change - 0.5));

-2
-3
-2

Adding 0.5 to a negative number moves it toward zero, and then truncating moves it toward zero again, so −2.7 ends up at −2. Subtracting 0.5 moves it away from zero first, so truncation lands on −3. Line 5 checks that a value closer to −2, such as −2.2, still rounds to −2.

public class RoundNoParens
{
    public static void main(String[] args)
    {
        double distance = 3.7;
        int rounded = (int) distance + 0.5;
        System.out.println(rounded);
    }
}

RoundNoParens.java:6: error: incompatible types: possible lossy conversion from double to int

System.out.println((int) (6.49 + 0.5));
System.out.println((int) (6.5 + 0.5));
System.out.println((int) (-1.5 - 0.5));

6
7
-2

double lowTemp = -4.6;
int rounded = (int) (lowTemp + 0.5);
System.out.println(rounded);

double lowTemp = -4.6;
int rounded = (int) (lowTemp - 0.5);
System.out.println(rounded);

-5

Could an int variable hold the number of people on Earth, about 8.1 billion? It seems like a number is a number. But every variable is a storage location in memory (Topic 1.2), and a storage location has a fixed size. The computer sets aside a specific amount of memory for each value based on its data type, and an int always gets the same amount: 4 bytes.

Memory is measured in bits and bytes. A bit is a single 0 or 1, and a byte is 8 bits. So an int has 4 × 8 = 32 bits. Each bit has two possible settings, so 32 bits can be set in 2 × 2 × … × 2 (32 times) = 4,294,967,296 different patterns. That is how many different int values exist, and no more. Think of a car’s trip counter with a fixed number of digit wheels: it can show only so many different readings.

Java splits those patterns between negative and nonnegative numbers: 2,147,483,648 of them for the negatives, and 2,147,483,648 for zero and the positives. Because zero takes one of the nonnegative slots, the largest positive int is one less in size than the most negative one. Those two limits are so important that Java gives them names:

• Integer.MAX_VALUE is the largest possible int, 2,147,483,647.
• Integer.MIN_VALUE is the smallest possible int, −2,147,483,648.

Each is a constant: a named value that never changes while the program runs. Integer is a class that comes with Java, and the dot means “the MAX_VALUE that belongs to Integer”; you will learn how classes and the values they contain work in Topics 1.7 and 1.10, so for now read each name as a whole. Constants are traditionally written in capital letters with underscores.

Every int value must be between Integer.MIN_VALUE and Integer.MAX_VALUE, inclusive, meaning both limits are themselves allowed.

System.out.print("Largest int: ");
System.out.println(Integer.MAX_VALUE);
System.out.print("Smallest int: ");
System.out.println(Integer.MIN_VALUE);

Largest int: 2147483647
Smallest int: -2147483648

Now try a value that is outside the range from the start. Java checks a number written directly in the code (a literal) when it compiles:

public class TooLargeLiteral
{
    public static void main(String[] args)
    {
        int worldPopulation = 8100000000;
        System.out.println(worldPopulation);
    }
}

TooLargeLiteral.java:5: error: integer number too large

8,100,000,000 is bigger than 2,147,483,647, so it cannot be an int at all. The compiler catches this one because the number is sitting right there in the code. As the next subsection shows, the compiler cannot catch a value that only becomes too large while the program runs.

System.out.print("Largest int: ");
System.out.println(Integer.MAX_VALUE);
System.out.print("Smallest int: ");
System.out.println(Integer.MIN_VALUE);

The compiler caught 8,100,000,000 because it was written in the code. But most numbers in a program are calculated while it runs. What happens when a calculation’s true answer is bigger than Integer.MAX_VALUE?

Return to the trip counter. If it shows 999999 and you drive one more mile, it does not stop or complain; it rolls over to 000000. An int behaves similarly. If an expression would produce an int value outside the allowed range, an integer overflow occurs. Java does not stop the program and does not report an error. It produces an int that is inside the range, but it is usually not the value you expected. Past the top of the range, the result wraps around to the bottom.

The analogy has a limit: the trip counter rolls over to zero, but an int that goes one past the top wraps to the most negative value, Integer.MIN_VALUE. That is because the negative values sit “after” the largest positive one in the way the 32 bits are arranged.

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

2147483647
-2147483648

int smallest = Integer.MIN_VALUE;
int oneLess = smallest - 1;
System.out.println(oneLess);

2147483647

Overflow does not need anything as obvious as Integer.MAX_VALUE. Here a program computes how many milliseconds (thousandths of a second) are in a 30-day month, and compares it with the number of seconds.

int millisInMonth = 30 * 24 * 60 * 60 * 1000;
System.out.println(millisInMonth);
int secondsInMonth = 30 * 24 * 60 * 60;
System.out.println(secondsInMonth);

-1702967296
2592000

The multiplications happen left to right:

The last step overflows, and the program prints a negative number of milliseconds, which is impossible. This is a logic error (Topic 1.1): the code compiles and runs, but the result is wrong. The second calculation stops before the * 1000, and 2,592,000 fits comfortably. Choosing a unit that keeps values in range (seconds instead of milliseconds) is one way to avoid overflow. You do not need to predict the exact wrong value an overflow produces in a case like this; what matters is recognizing when a calculation goes past the limits.

int first = 2000000000;
int second = 2000000000;
int average = (first + second) / 2;
System.out.println(average);

-147483648

int first = 2000000000;
int second = 2000000000;
int average = first / 2 + second / 2;
System.out.println(average);

2000000000

int low = Integer.MIN_VALUE;
int below = low - 1;
int stepBack = below + 1;
System.out.println(below);
System.out.println(stepBack);

2147483647
-2147483648

int seconds = 60 * 60 * 24 * 365;
int big = 2000000000 + 100000000;
int total = 1000000 * 3000;
int small = 0 - 2000000000;
System.out.println(seconds);
System.out.println(big);
System.out.println(total);
System.out.println(small);

31536000
2100000000
-1294967296
-2000000000

Add 0.1 and 0.2 on a calculator and you get 0.3. Ask Java:

System.out.println(0.1 + 0.2);
System.out.println(1.0 - 0.9);

0.30000000000000004
0.09999999999999998

Both answers are off by a tiny amount. This is not a bug in Java; it comes from the same fact as the last two subsections. A double is stored in a fixed amount of memory (8 bytes), so it can hold only a limited number of digits. Just as an int has a largest value, a double has a limit on how precise it can be: how many digits it can keep.

You have seen this problem with fractions. One third written as a decimal is 0.3333… forever, so on paper you must stop somewhere and round. A double stores its digits in binary (0s and 1s), and in binary, simple decimals like 0.1 and 0.2 repeat forever, the way 1/3 does in decimal. So Java stores the closest value it can, which is very slightly off. When a calculation’s exact answer has more digits than a double can hold, the result is rounded to the nearest value a double can store. The small difference is called a round-off error.

int values do not have this problem. Every whole number in the int range is stored exactly, and adding, subtracting, or multiplying them gives exact results (as long as nothing overflows). So when exact results matter, store the values as int.

double price = 1.10;
double total = price * 3;
System.out.println(total);

3.3000000000000003

int priceInCents = 110;
int totalCents = priceInCents * 3;
System.out.println(totalCents);
System.out.print("Dollars: ");
System.out.println(totalCents / 100);
System.out.print("Cents: ");
System.out.println(totalCents % 100);

330
Dollars: 3
Cents: 30

double price = 0.29;
System.out.println(price * 100);
int truncated = (int) (price * 100);
System.out.println(truncated);
int rounded = (int) (price * 100 + 0.5);
System.out.println(rounded);

28.999999999999996
28
29

A science class records the low temperature, as a whole number of degrees, on three winter days: −3, −3, and −2. The program below reports the average four ways. Before reading the output, predict each line.

public class TemperatureAverage
{
    public static void main(String[] args)
    {
        int monday = -3;
        int tuesday = -3;
        int wednesday = -2;
        int sum = monday + tuesday + wednesday;
        System.out.print("int division: ");
        System.out.println(sum / 3);
        double average = (double) sum / 3;
        System.out.print("Exact average: ");
        System.out.println(average);
        System.out.print("Truncated: ");
        System.out.println((int) average);
        System.out.print("Rounded: ");
        System.out.println((int) (average - 0.5));
    }
}

int division: -2
Exact average: -2.6666666666666665
Truncated: -2
Rounded: -3

What each idea contributed:

• Casting an operand (1.5.3). Without (double) on line 11, the division would be int division and the average would be -2.0. The cast goes on sum, before the division, not around sum / 3.
• Truncation toward zero (1.5.2). int division and the (int) cast both give −2, because both drop the decimal part. On a number line, −2.666… is closer to −3, so neither one rounds.
• Rounding (1.5.4). The average is negative, so the program uses (int) (average - 0.5). Using + 0.5 would give (int) (-2.1666…), which is -2, the wrong answer.
• Round-off (1.5.7). The exact average is −2⅔, whose decimal digits go on forever. A double cannot hold them all, so the last printed digit is 5, the stored value rounded to the nearest one a double can hold.
• Range (1.5.5 and 1.5.6). Temperatures are small numbers, so no step comes anywhere near Integer.MAX_VALUE or Integer.MIN_VALUE; overflow is not a concern here. It would be if the program summed millions of large values.

• Java automatically widens an int to a double when a double is needed, in an assignment or in an operation with a double operand. It never turns a double into an int on its own, because the decimal part could be lost.
• A cast converts a value on purpose. (int) truncates a double toward zero, and (double) turns an int into a double. A cast applies only to the value right after it, so cast an operand before dividing to keep the decimal part.
• Round a double to the nearest int with (int) (x + 0.5) when x is zero or positive, and (int) (x - 0.5) when x is negative.
• An int is stored in 4 bytes, so its values run from Integer.MIN_VALUE (−2,147,483,648) to Integer.MAX_VALUE (2,147,483,647), inclusive. An int expression that would go outside that range overflows and quietly gives an unexpected value.
• A double has limited precision, so some results carry a small round-off error. Use int values, such as cents instead of dollars, when results must be exact.

double result = 9 / 2 + 1.5;
System.out.println(result);

5.5

int laps = 17;
double perDay = laps / 5;
double exact = (double) laps / 5;
int whole = (int) exact;
int nearest = (int) (exact + 0.5);
System.out.println(perDay);
System.out.println(exact);
System.out.println(whole);
System.out.println(nearest);

3.0
3.4
3
3

int correct = 7;
int total = 8;
int percent = correct / total * 100;
System.out.println(percent);

int correct = 7;
int total = 8;
int percent = (int) ((double) correct / total * 100 + 0.5);
System.out.println(percent);

88

int correct = 7;
int total = 8;
int percent = (int) ((double) correct / total * 100);
System.out.println(percent);

87

int points = 2147483000;
points = points + 1000;
System.out.println(points);

double ratio = (double) (int) 7.8 / 2;
System.out.println(ratio);

• I can explain when Java widens an int to a double and why it never narrows a double to an int on its own. Reread
• I can predict the result of (int) on positive and negative double values. Reread
• I can place a (double) cast so that a division keeps its decimal part. Reread
• I can round a positive or negative double to the nearest int. Reread
• I can state the smallest and largest int values and explain why the range is limited. Reread
• I can recognize when an int calculation overflows and describe what happens. Reread
• I can explain round-off error and when to use int values instead of double. Reread