Java Operators - Complete Guide

1. Introduction to Java Operators

Operators perform calculations, comparisons, and logical tests on operands. Java supports arithmetic, relational, logical, bitwise, assignment, and ternary operators.

• Unary: ++, --, !
• Binary: +, -, *, /, %
• Relational: ==, !=, <, >, <=, >=
• Logical: &&, ||, !

public class OperatorIntro {
    public static void main(String[] args) {
        int a = 10, b = 3;
        System.out.println(a + b);
        System.out.println(a % b);
        System.out.println(a > b);
    }
}

2. Java Operators by Type

Each category below lists operators with their purpose and a short example. Use these tables as a quick reference while coding or preparing for interviews.

Arithmetic operators

Unary operators

Relational (comparison) operators

Logical operators

Bitwise operators

Assignment operators

Ternary and other operators

3. How Bitwise Operators Work (Positive & Negative)

Bitwise operators (&, |, ^, ~, <<, >>, >>>) work on the binary bits of int, long, byte, and short. In Java, signed integers use two's complement to represent negative numbers.

Positive numbers in binary

Non-negative values use normal binary: each bit is a power of two. Example with 8 bits (for clarity; int uses 32 bits):

Negative numbers — two's complement

To store -n: flip all bits of +n (one's complement), then add 1. Equivalently in Java: -n == ~n + 1 (for the same type).

Bitwise AND (&) — positive and negative

Result bit is 1 only if both operands have 1 in that position.

Common use: value & 0xFF keeps the lowest 8 bits (works the same whether the high bits are 0 or 1).

Bitwise OR (|) and XOR (^)

Bitwise NOT (~)

Flips every bit. For signed integers, ~n == -(n + 1).

Left shift (<<) — positive and negative

Shifts bits left; vacated right bits are filled with 0. For non-negative values, n << k is like multiplying by 2^k (until overflow).

Right shift — signed (>>) vs unsigned (>>>)

This is where positive and negative behave differently.

public class BitwiseSignedDemo {
    public static void main(String[] args) {
        int a = 12, b = 10;
        System.out.println("12 & 10 = " + (a & b));   // 8
        System.out.println("12 | 10 = " + (a | b));   // 14
        System.out.println("12 ^ 10 = " + (a ^ b));   // 6

        int n = 5;
        System.out.println("~5 = " + (~n));           // -6
        System.out.println("5 << 2 = " + (n << 2));     // 20

        int neg = -8;
        System.out.println("-8 >> 1 = " + (neg >> 1));   // -4
        System.out.println("-8 >>> 1 = " + (neg >>> 1)); // 2147483644

        int mask = -1;
        System.out.println("-1 >> 1 = " + (mask >> 1));   // -1
        System.out.println("-1 >>> 1 = " + (mask >>> 1)); // 2147483647

        // Two's complement check
        System.out.println("-5 in binary (32-bit): " + Integer.toBinaryString(-5));
        System.out.println("~5 + 1 = " + ((~5) + 1)); // -5
    }
}

4. Operator Precedence and Associativity

When multiple operators appear in one expression, precedence determines evaluation order. Use parentheses to make intent explicit and avoid subtle bugs.

• Multiplication before addition
• Relational before logical AND
• Assignment has low precedence
• Most operators associate left-to-right

public class PrecedenceDemo {
    public static void main(String[] args) {
        int result = 2 + 3 * 4;
        System.out.println(result);
        System.out.println((2 + 3) * 4);
    }
}

5. Operator Examples

Short-circuit logical operators (&& and ||) skip the right operand when the result is already determined. This prevents null pointer errors in chained conditions.

• Use && instead of & for boolean logic
• Prefix ++i increments before use
• Compound assignment: x += 5
• String + concatenates text

public class LogicDemo {
    public static void main(String[] args) {
        String name = null;
        if (name != null && name.length() > 0) {
            System.out.println(name);
        } else {
            System.out.println("No name");
        }
    }
}

6. Operators Best Practices

Clear expressions reduce bugs in interviews and production code. Prefer readability over clever one-liners.

• Use parentheses for complex expressions
• Avoid mixing ++ with other operators in one line
• Compare strings with equals(), not ==
• Use Math methods for advanced math
• Watch integer division truncation

7. Tricky Points

Common operator pitfalls in Java interviews and real code — grouped by operator type.

Arithmetic

Unary and increment

Relational and logical

Bitwise

Assignment, ternary, and precedence