Operators in Java

1. Arithmetic Operator

Arithmetic operators in Java are used to perform basic mathematical calculations such as addition, subtraction, multiplication, division, and modulus.

Compound Expression Examples:

3 * x + 5 - 7
principle + (principle + interest)
    

2. Assignment Operator

• The assignment operator has the lowest precedence of all operators.
• It is always evaluated last.
• It assigns the value of an expression to a variable.
• The previous value of the variable is overwritten by the new expression value.

x = x + 10;
isVisible = true;
timeInSecond = distance / speedOfLight;
      

Code Example:

// Add Assignment (+=)
int a = 20; 
a += 5;   // same as a = a + 5;
System.out.print(a);  // OUTPUT: 25

// Multiply Assignment (*=)
a *= 5;   // same as a = a * 5;
System.out.print(a);  // OUTPUT: 100

// Other compound assignments:
// -=, /=, %=, <<=, >>=, &=, ^=, |=
    

3. Increment / Decrement Operator

These operators are used to increase or decrease the value of a variable by 1.

Code Example:

int x = 5;

System.out.println(++x);  
// OUTPUT: 6 (pre-increment)

System.out.println(x++);  
// OUTPUT: 6 (post-increment, x=7 afterwards)

System.out.println(--x);  
// OUTPUT: 6 (pre-decrement)

System.out.println(x--);  
// OUTPUT: 6 (post-decrement, x=5 afterwards)
    

4. Relational Operator

Relational operators are used to compare two values. The result of a relational expression is always a boolean → true or false.

Code Example:

int a = 5, b = 10;

System.out.println(a > b);   // false
System.out.println(a < b);   // true
System.out.println(a == b);  // false
System.out.println(a != b);  // true

a = 10; b = 5;
System.out.println(a >= b);  // true
System.out.println(a <= b);  // false
    

5. Logical Operator

Logical operators are used when we want to combine multiple relational expressions. The result of a logical expression is always a boolean (true or false).

Logical AND (&&)

Returns true only if both expressions are true.

Logical OR (||)

Returns true if at least one expression is true.

Logical NOT (!)

Flips the result: true → false, false → true.

Code Example

int x = 6;

boolean b1 = (x > 5) && (x < 10);
System.out.println(b1);   // true

boolean b2 = (x > 5) && (x != 6);
System.out.println(b2);   // false

boolean b3 = (x > 5) || (x != 6);
System.out.println(b3);   // true

boolean b4 = !(x > 5);
System.out.println(b4);   // false
    

6. Bitwise Operator

Bitwise operators perform operations directly on the bits of numbers.

Code Example

class Test {
  public static void main(String[] args) {
    int a = 6;  // 0000 0110
    int b = 3;  // 0000 0011

    int r1 = a & b;  // 2
    int r2 = a | b;  // 7
    int r3 = a ^ b;  // 5
    int r4 = ~a;     // -7

    System.out.println(r1 + ", " + r2 + ", " + r3 + ", " + r4);
  }
}
    

Explanation: a = 6 (0000 0110), b = 3 (0000 0011)
a & b = 2, a | b = 7, a ^ b = 5, ~a = -7

7. Conditional Operator (? :)

Conditional (ternary) operator is a shorthand if-else that evaluates a boolean expression and returns one of two values.

Code Example

public class Test {
  public static void main(String[] args) {
    int a = 10, b = 20;
    int max = (a > b) ? a : b;
    System.out.println("Max = " + max);
  }
}
    

Output: Max = 20

8. Shift Operator ( << ,>> , >>> )

Shift operators are used to move the bits of a number towards left or right. They are commonly used for fast multiplication/division by powers of 2.

• Left Shift ( << ): Shifts bits to the left, filling with 0s. Equivalent to multiplying by 2 for each shift.
• Right Shift ( >> ): Shifts bits to the right, preserving the sign bit (MSB).
• Unsigned Right Shift ( >>> ): Shifts bits to the right, filling with 0s (ignores sign bit).

Code Example

// 1. Left Shift ( << )
class Test {
  public static void main(String[] args) {
    int x = 6 << 2;
    System.out.println(x);  
    // OUTPUT: 24
  }
}

// 2. Right Shift ( >> )
class Test {
  public static void main(String[] args) {
    int x = 6 >> 2;
    System.out.println(x);  
    // OUTPUT: 1
  }
}

// 3. Unsigned Right Shift ( >>> )
class Test {
  public static void main(String[] args) {
    int x = 6 >>> 2;
    System.out.println(x);  
    // OUTPUT: 1
  }
}
    

Explanation

6 << 2
6 = 0000 0110
1st shift -> 0000 1100
2nd shift -> 0001 1000 = 24

6 >> 2
6 = 0000 0110
1st shift -> 0000 0011
2nd shift -> 0000 0001 = 1
    

9. instanceof Operator

The instanceof operator is used only for object reference variables. It checks whether an object is an instance of a particular class or implements an interface. The result is always a boolean value (true or false).

Syntax

(ref.variable) instanceof (class/interface)
    

Code Example

class Test {
  public static void main(String[] args) {
    String name = "Ayan";

    // returns true since 'name' is of type String
    boolean res = name instanceof String;
    System.out.println(res);
  }
}
    

Output: true