Operators

1. Division and remainder with whole numbers

System.out.println(7 / 2);      // 3
System.out.println(7 % 2);      // 1

When both values are whole numbers, Java drops the fractional part. % gives the remainder.

Negative values follow two rules:

System.out.println(-7 / 2);     // -3, not -4
System.out.println(-7 % 3);     // -1, not 2
System.out.println(7 % -3);     //  1

• Division moves towards zero. It does not use Math.floor.
• The remainder has the same sign as the left value.

For every non-zero divisor, Java preserves this identity:

(a / b) * b + (a % b) == a

For a = -7 and b = 3, division gives -2 and remainder gives -1. Substitution gives (-2 * 3) + -1, which is -7. The remainder magnitude is always smaller than the divisor magnitude.

Python gives a different result for -7 % 3: 2. In Java it is -1. This matters when you check whether a number is odd:

if (n % 2 == 1) { }   // wrong for negative odd values
if (n % 2 != 0) { }   // works for positive and negative values

2. Compound assignment adds a cast

byte b = 10;
b = b + 300;      // ERROR: incompatible types: possible lossy conversion

b + 300 is an int. Java will not put that int back into a byte unless you make the narrowing explicit.

Now compare it with this:

byte b = 10;
b += 300;         // compiles
System.out.println(b);   // 54

+= is not the same as b = b + 300. For this local variable, it has the same value effect as:

b = (byte) (b + 300);

Java adds the cast. The value 310 is narrowed to eight bits, leaving 54.

There is another difference when the left side is an expression. A compound assignment evaluates that left side once.

public class CompoundDemo {
    static int calls;

    static int index() {
        calls++;
        return 0;
    }

    public static void main(String[] args) {
        int[] values = {10};
        values[index()] += 5;
        System.out.println(values[0]);
        System.out.println(calls);
    }
}

Output:

15
1

Rewriting that line as values[index()] = values[index()] + 5 calls index() twice. The formal rule is close to E1 = (T) (E1 op E2), except that E1 is evaluated only once.

3. Pre-increment and post-increment

Both forms add one. They differ in the value the expression returns.

int i = 5;
System.out.println(i++);   // prints 5, then i becomes 6

int j = 5;
System.out.println(++j);   // j becomes 6, then prints 6

In a loop update, i++; and ++i; have the same effect. Avoid mixing either form into larger expressions. The result is valid Java, but it is harder to read and review.

4. Short-circuit evaluation

&& and || stop when the result is already known.

• false && anything is false, so Java does not evaluate anything.
• true || anything is true, so Java does not evaluate anything.

if (user != null && user.getName().isEmpty()) { }   // safe
if (user.getName().isEmpty() && user != null) { }   // fails when user is null

Java also has & and | for booleans. They evaluate both sides every time.

5. Bitwise operators

Bitwise operators treat a number as a row of bits. They work on each position separately.

Take 12 and 10:

~12 is -13 because Java flips all 32 bits, then reads the result as a two’s-complement int. A useful shortcut is ~x = -x - 1.

6. Shift operators

<< moves bits left. >> and >>> move them right.

System.out.println(20 << 2);    // 80
System.out.println(20 >> 2);    // 5

When no significant bits are discarded, shifting a positive value left by n has the same result as multiplying by 2^n. Bits that leave the fixed 32-bit or 64-bit width are discarded, so overflow can break that arithmetic shortcut.

System.out.println(1 << 30);   // 1073741824
System.out.println(1 << 31);   // -2147483648
System.out.println(1 << 32);   // 1

The last line is not a 33-bit result. For an int, Java uses only the low five bits of the shift distance, so the effective distance is distance & 31. 32 & 31 is 0. For a long, Java uses the low six bits, which is distance & 63.

Signed right shift is also not the same as division for every negative odd number:

System.out.println(-3 / 2);    // -1, division truncates toward zero
System.out.println(-3 >> 1);   // -2, sign-extending shift rounds downward here

Negative values show the difference between the two right shifts:

System.out.println(-20 >> 2);     // -5
System.out.println(-20 >>> 2);    // 1073741819

>> copies the sign bit. >>> fills with zeros. When an int represents flags or part of a hash, that distinction matters.

7. The ternary operator

The ternary operator chooses one of two values.

int max = (a > b) ? a : b;

Read it as: condition, value when true, value when false. It works well for a short choice. Nested ternaries are hard to read, so use an if instead.

8. Precedence and associativity

2 + 3 * 4 is 14 because * binds more tightly than +.

The complete precedence table has about fifteen levels. Remember the common order, then use parentheses when there is any doubt:

One common surprise is that bitwise & has lower precedence than ==:

if (flags & MASK == 0)      // parsed as flags & (MASK == 0), so it is a type error
if ((flags & MASK) == 0)    // correct

Write the parentheses every time. They state the test clearly.