Operators: /, % and precedence

One of the topics that earns the most points on the midterm. The question type is always the same: “What is printed?”. You run the code in your head and write the output. Anyone who knows the five rules below will not miss these questions:

1. int / int = int. The fractional part is dropped, there is no rounding: 7 / 2 → 3.
2. If one side is a double, the result is a double. 7.0 / 2 → 3.5.
3. % gives the remainder, and the sign of the result is the sign of the left number: -7 % 2 → -1.
4. * / % first, + - after. Operators at the same level are evaluated left to right.
5. Parentheses override everything. A (int) cast applies only to the value immediately to its right.

Arithmetic operators

Java has five arithmetic operators. Addition, subtraction and multiplication work the way you know. The two that decide the exam are / and %, because the result changes with the types.

A double result is printed with .0 even when it is a whole number: 9.0, 14.0. Whether you write 9 or 9.0 in an output question is the difference between points gained and lost.

Division: integer division

When both sides of a division are int, Java computes the quotient and drops everything after the decimal point. This is called integer division. It does not round: 9 / 10 is 0, not 0.9.

System.out.println(7 / 2);    // 3.5 → truncated
System.out.println(9 / 10);   // 0.9 → 0
System.out.println(19 / 5);   // 3.8 → 3 (it would be 4 if it rounded)
System.out.println(-7 / 2);   // -3.5 → truncated toward zero
System.out.println(10 / 5);   // divides exactly

3
0
3
-3
2

Careful with negatives: Java truncates toward zero. -3.5 → -3, not -4. With a negative number too, you just delete the fractional part.

Type promotion

If one side of the division is a double, Java makes the other one a double too and does a real division. What matters is what the types are at the moment the division is done.

System.out.println(7.0 / 2);          // double / int
System.out.println(7 / 2.0);          // int / double
System.out.println((double) 7 / 2);   // cast FIRST: 7.0 / 2
System.out.println((double) (7 / 2)); // parentheses FIRST: 7/2 = 3
double d = 7 / 2;                     // the right side is an int division
System.out.println(d);

3.5
3.5
3.5
3.0
3.0

PITFALL · assigning to a double variable does not save you. In the line double d = 7 / 2; the result is 3.0, not 3.5. The right side is computed first: 7 / 2 is two ints, the result is 3. The fraction is already gone; assigning to a double only adds .0.

Division by zero

System.out.println(5.0 / 0);  // double: does not crash
System.out.println(5 / 0);    // int: the program CRASHES

Infinity
Exception in thread "main" java.lang.ArithmeticException: / by zero

The remainder operator: %

a % b is the number that is left over when you divide a by b. The following equality always holds:

$a = (a / b)\cdot b + (a \,\%\, b) \qquad \text{example: } 17 = 3\cdot 5 + 2$

When computing, think “what is the largest multiple of b that fits into a?” and subtract it from a. 17 % 5: the largest multiple of 5 that fits into 17 is 15, 17 − 15 = 2.

System.out.println(17 % 5);   // 17 = 3*5 + 2
System.out.println(20 % 5);   // divides exactly
System.out.println(3 % 5);    // small % big = itself
System.out.println(-7 % 2);   // the sign is the LEFT one's
System.out.println(7 % -2);   // the left is positive
System.out.println(5.5 % 2);  // works with doubles too

2
0
3
-1
1
1.5

PITFALL · small % big. 3 % 5 is a question where most people write 2 or 0. 5 does not fit into 3 at all. The remainder is 3 itself: 3.

Ready-made tricks with %

Method questions such as digit sum, digit count and reversing a number are all built on this two-line pattern:

int n = 1234, sum = 0;
while (n > 0) {
    sum += n % 10;   // take the last digit
    n /= 10;         // drop the last digit
}
System.out.println(sum);

10

Precedence order

When an expression has more than one operator, Java works in the following order. The ones at the top are done first. Operators on the same row are done left to right; only assignment = goes right to left.

PITFALL · * / % are at the same level. There is no rule like “multiplication first, then division”. 20 / 4 * 2 goes left to right: 20 / 4 = 5, 5 * 2 = 10. Whoever writes 2.5 gets burned.

Step-by-step solutions

In the exam, solve it like this: at each step process only one operator and rewrite the expression.

7 + 3 % 2 * 5

7 + 3 % 2 * 5     % and * are at the same level, the left one first
7 + 1 * 5
7 + 5
12

1 / 2 * 4.0 versus 4.0 * 1 / 2

1 / 2 * 4.0   →   0 * 4.0   →   0.0      (two ints were divided first)
4.0 * 1 / 2   →   4.0 / 2   →   2.0      (it started with a double)

Same numbers, different order, different result: the types at the moment the division is done are what decide.

(int) 7.9 / 2 versus (int) (7.9 / 2)

(int) 7.9 / 2     →   7 / 2      →   3     (the cast applies only to 7.9)
(int) (7.9 / 2)   →   (int) 3.95 →   3     (truncated, not rounded)

+ with a String

+ does addition between two numbers. The moment one side is a String, it does concatenation. Because it goes left to right, the order changes everything.

System.out.println(1 + 2 + "A");       // (1+2)=3, then "3"+"A"
System.out.println("A" + 1 + 2);       // "A1", then "A12"
System.out.println("A" + (1 + 2));     // parentheses first
System.out.println("Sonuç: " + 5 * 2); // * first

3A
A12
A3
Sonuç: 10

"x" + 5 - 2, on the other hand, does not compile: first it becomes "x5", and then you cannot subtract a number from a String.

Common mistakes

System.out.println(17 / 5 + 17 % 5);

System.out.println(2 + 3 * 4 % 5);

double d = 9 / 2;
System.out.println(d);

System.out.println((double) 9 / 2);

System.out.println(-9 % 4);

System.out.println(10 - 6 / 4 * 2);

System.out.println(1 + 2 + "3" + 4 + 5);

int n = 4567;
System.out.println(n / 10 % 10);

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

System.out.println((int) 8.9 / 2 + 8 % 3);

int a = 7;
a %= 4;
a *= 3;
a /= 2;

int a = 5, b = 2, c = 4;
double avg = (a + b + c) / 3;
System.out.println(avg);