Java Operators: Arithmetic, Comparison, Logical, and Assignment

What Operators Do

Operators are the symbols that combine values to compute new ones. You already use them informally - + adds, > compares - and Java groups them into a few families: arithmetic, comparison, logical, assignment, and a couple of specials like increment and the ternary.

Most operators take two values (one before, one after the symbol) and produce a result. The trick is knowing what type that result is and the order they apply in - which is where beginners trip up.

Arithmetic Operators

The five arithmetic operators work on numbers: +, -, *, /, and % (remainder).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (integer division!)
        System.out.println(a % b);   // 2  (the remainder)
    }
}

The % operator is the remainder after division: 17 % 5 is 2 because 5 goes into 17 three times with 2 left over. It is the everyday tool for testing divisibility - n % 2 == 0 is the standard "is n even?" check.

Note also that + does double duty: with numbers it adds, but with a String on either side it joins text.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

The first line reads left to right: "Total: " + 3 is already a string, so the 4 is appended as text. Wrap the math in parentheses when you want it computed first.

The Integer-Division Gotcha

This is the single most common surprise. When both operands of / are integers, Java does integer division and discards the fraction - it does not round, it truncates toward zero.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, not 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (one double is enough)
        System.out.println((double) 5 / 2); // 2.5 (cast one operand)
    }
}

To get a decimal result, make at least one operand a double - either write it with a .0, or cast one side with (double). Casting (double)(5 / 2) does not help, because the integer division 5 / 2 already happened before the cast; you must cast an operand, not the result.

Comparison Operators

Comparison operators ask a yes/no question and return a boolean. There are six: ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

Watch the difference between = (assignment - "put this value here") and == (comparison - "are these equal?"). Mixing them up is a classic bug.

One important caveat: == compares object references, not contents. For strings, use .equals().

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - different objects
        System.out.println(a.equals(b));   // true  - same text
    }
}

Use == for primitives like int and boolean, and .equals() whenever you compare the contents of objects such as strings.

Logical Operators

Logical operators combine boolean values: && (and), || (or), and ! (not). They are how you express conditions like "old enough and has a ticket".

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& and || short-circuit: Java stops evaluating as soon as the answer is certain. With &&, if the left side is false the right side is never checked; with ||, if the left side is true the right side is skipped. This is not just an optimization - you can lean on it for safety:

if (text != null && text.length() > 0) { ... }

If text is null, the left side is false and text.length() is never called, avoiding a NullPointerException. Reverse the order and it would crash.

Assignment and Increment

= assigns, but Java also has compound assignments that combine an operation with assignment: +=, -=, *=, /=, %=. And ++ / -- add or subtract one.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ comes in two flavors: postfix (count++) returns the old value then increments; prefix (++count) increments first then returns the new value. The difference only matters when you use the result in the same expression:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // prints 5, then x becomes 6
        System.out.println(++x);   // x becomes 7, prints 7
    }
}

When ++ is on its own line, postfix vs prefix make no difference - so prefer whichever reads clearly and don't cram increments into bigger expressions.

The Ternary Operator

The ternary condition ? a : b is a compact if/else that produces a value: if the condition is true it evaluates to a, otherwise b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

It shines for short either/or assignments. Resist nesting ternaries inside ternaries - that gets unreadable fast, and a plain if/else is clearer.

Precedence and Parentheses

Operators apply in a fixed order, much like math: *, /, % bind tighter than + and -, which bind tighter than comparisons, which bind tighter than &&, then ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, not 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

You don't need to memorize the full table. When an expression mixes families or you have to pause to work out the order, add parentheses - they cost nothing and make intent obvious to the next reader.

Next: Type Casting

Several gotchas here - integer division, mixing int and double - come down to types. Converting between number types deliberately is called casting, and that is the next page.