Java Operators

Operators are special symbols that perform operations on one, two, or three operands and return a result. Java groups operators by the kind of work they do, and understanding each group's precedence and behavior is essential for writing correct expressions.

Why it matters

Operators are where most small logic errors live: an integer division that drops the remainder, a condition that evaluates something it should have skipped, or == used where equals() was needed. These are easy to write, hard to spot in review, and they are favourite material for "what does this print?" interview questions.

Arithmetic Operators

+ - * / % perform addition, subtraction, multiplication, division, and modulus (remainder). Integer division truncates toward zero (7 / 2 is 3, not 3.5), while division involving at least one floating-point operand produces a decimal result.

Relational and Logical Operators

Relational operators (== != > < >= <=</code>) compare two values and produce a boolean. Logical operators (&& || !) combine boolean expressions. && and || are short-circuiting: the right-hand side is not evaluated if the result is already determined by the left-hand side, which is important when the right side has side effects.

Assignment and Compound Assignment

= assigns a value. Compound assignment operators like += -= *= /= %= combine an operation with assignment, and they also perform an implicit narrowing cast — byte b = 10; b += 5; compiles even though b = b + 5; would not.

Increment, Decrement, Ternary, and Bitwise Operators

++ and -- increase or decrease a value by 1, with prefix (++x) applying before use and postfix (x++) applying after use in an expression. The ternary operator condition ? valueIfTrue : valueIfFalse is a compact conditional expression. Bitwise operators (& | ^ ~ << >> >>>) operate directly on the binary representation of integer types.

Example

public class OperatorsDemo {
    public static void main(String[] args) {
        System.out.println(7 / 2);       // integer division
        System.out.println(7.0 / 2);     // floating-point division
        System.out.println(7 % 2);       // modulus

        int x = 5;
        boolean result = (x > 0) || (10 / 0 == 0); // short-circuit, avoids division by zero
        System.out.println(result);

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

        int score = 85;
        String grade = score >= 90 ? "A" : score >= 75 ? "B" : "C";
        System.out.println(grade);
    }
}

3
3.5
1
true
5
7
B

Exercise

Write the leap-year rule using the modulus and logical operators. A year is a leap year if it is divisible by 4 and not by 100, unless it is also divisible by 400.

Expected output: 2024 true, 1900 false, 2000 true, each on its own line.

public class LeapYear {

    static boolean isLeap(int year) {
        // TODO: return true when year is a leap year
        return false;
    }

    public static void main(String[] args) {
        System.out.println("2024 " + isLeap(2024));
        System.out.println("1900 " + isLeap(1900));
        System.out.println("2000 " + isLeap(2000));
    }
}

public class LeapYear {

    static boolean isLeap(int year) {
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    }

    public static void main(String[] args) {
        System.out.println("2024 " + isLeap(2024));
        System.out.println("1900 " + isLeap(1900));
        System.out.println("2000 " + isLeap(2000));
    }
}

Quick quiz

Interview questions