Prev Next
An operator is used to perform an operation over one or more operands. Operators in Java are classified as,
 Assignment Operator
 Arithmetic Operator
 Unary Operator
 Relational Operator
 Logical / Conditional Operator
 Bitwise Operator
1. Arithmetic Operators:
They are used to perform arithmetic operations over two operands.
Operator

Description

+  Adds both of the operands and returns the result. Example: int a = 10, b=2, c; c = a + b; //c = 12 
–  Subtracts the right hand side operand from the left hand side operand. Example: c = a – b; //c = 2 
*  Multiplies both the operands and returns the result. Example: c = a * b; //c = 20 
/  Divides left hand side operand by the right hand side operand. Example: c = a / b; //c =5 
%  Divides left hand side operand by the right hand side operand and returns the reminder. Example: c = a % b; //c = 0 
2. Unary Operators:
They are used to perform operations over a single operand.
Operator

Description

+ (Unary plus)  For referring +ve values. By default all values are positive.
Example: int a = +5;

– (Unary Minus)  Negates a value. Example: int a = 5; 
++operand 
First increments the operand value by 1 and then the new value is used in the expression. The value of the operand is first used in the expression and then incremented by 1.
Example: Preincrement: Example: Postincrement: 
– – operand (Pre_Decrement)operand – – (Post_Decrement) 
First decrements the operand value by 1 and then the new value is used in the expression. The value of the operand is used in the expression first and then decremented by 1.
Example: Predecrement: Example: Postdecrement: 
(Logical NOT operator)  Complement operator. It inverts the logical state of an operand. Example: boolean flag = !true; /* flag will contain false */ !(A= =B) /* inverts the result of the expression */ 
3. Relational Operators:
They are used to compare the values of two operands.
Operator

Description

==  Checks whether values of both side of the operands are equal. Example: int a = 10, b = 10; boolean var = (a == b);Can be used in conditional statements like below: if (a == b) { System.out.println(“values are equal”); }Can be used in loops like below: for(i=0; a==b;i++){ } while(a==b) { } 
!=  Checks whether values of both the operands are unequal. Example: check = (a! = b); // true if ‘a’ is not equal to ‘b’ 
> 
Checks whether the operand in the left hand side is greater than the right hand side operand. Example: int a = 5, b = 2; (a > b) would return true. 
<  Checks whether the operand in the left hand side is less than the right hand side operand. Example: int a = 5, b = 2; (a < b) would return false. 
>=  Checks whether the operand in the left hand side is greater than or equal to the right hand side operand. Example: int a = 2, b = 2; (a >= b) would return true. 
<=  Checks whether the operand in the left hand side is less than or equal to the right hand side operand. Example: int a = 3, b = 2; (a <= b) would return false. 
4. Logical / Conditional Operators:
Operator

Description

&& (Logical AND) 
If both the operands are true, then the condition evaluates to true. Otherwise as false. Consider X = true, Y = true. (X && Y) evaluates to true 
  (Logical OR) 
If any of the operand is true, then the condition evaluates to true. Otherwise as false. Consider X = true, Y = true (X   Y) evaluates to true 
? : (Ternary operator) 
This operator requires 3 operands. It represents short hand form of ‘if else’ loop.
Syntax: Example: 
5. Bitwise Operators:
Operator

Description

~ (Bitwise complement) 
This operator inverts a bit pattern making 0’s to 1 and 1’s to 0. 
& (Bitwise AND) 
Performs bitwise AND operation. Example: consider x = 15, y = 6 (x = 0000 1111, y = 0000 0110) x&y = 6 (0000 0110) 
 (Bitwise inclusive OR) 
Performs bitwise OR operation. Example: consider x = 14, y = 12 (x = 0000 1110, y = 0000 1100) xy = 14 (0000 1110) 
^ (Bitwise exclusive OR) 
Performs bitwise XOR operation. Example: consider x = 15, y = 12 (x = 0000 1111, y = 0000 1100) x^y = 3 (0000 0011) 
<< (Left shift) 
The operand’s value is moved left by the number of bits specified in the right side of the operator <<. Example: consider x = 7 (0000 0111) x<<2 = 24 (0001 1100) 
>> (Right shift) 
The operand’s value is moved right by the number of bits specified in the right side of the operator >>. Example: consider x = 7 (0000 0111) x>>2 = 1 (0001) 
>>> (Zero fill right shift) 
Same as right shift, fills zero in the shifted places. Example: consider x = 7 (0000 0111) x>>>2 = 1 (0000 0001) 
6. Assignment Operator:
The Assignment operator ‘=’ is used to assign the value on the right hand side to the operand on the left.
Example:
int i = 1;
The value 1 is assigned to the variable ‘i’.
Operator

Description

+=  Performs addition & assigns the result to the left hand side. Example: x+=2; //(x = x+2) 
=  Performs subtraction and assigns the result to the left hand side. Example: x=2; //(x = x2) 
*=  Performs multiplication and assigns the result to the left hand side. Example: x*=2; //(x = x*2) 
/=  Performs division and assigns the result to the left hand side. Example: x/=2; //(x = x/2) 
%=  Performs division and assigns the remainder to the left hand side. Example: x%=2; //(x = x%2) 
<<=  Performs left shift and assigns the result to the left hand side. Example: x<<=2; //(x = x<<2) 
>>=  Performs right shift and assigns the result to the left hand side. Example: x>>=2; //(x = x>>2) 
&=  Performs Bitwise & and assigns the result to the left hand side. Example: x&=2; //(x = x&2) 
^=  Performs Bitwise ^ and assigns the result to the left hand side. Example: x^=2; //(x = x^2) 
=  Performs Bitwise  and assigns the result to the left hand side. Example: x=2; //(x = x2) 
The instanceof Operator (Type comparison operator):
The instanceof operator is used to check whether an object is an instance of a particular type (class, array).
Example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 
Class Employee { int eid; String name; public void display() { System.out.println(“ID:”+eid); System.out.println(“Name:”+name); } public static void main(String args[]) { Employee e1 = new Employee(); System.out.println(Is e1 object of Employee:’+(e1 instanceof Employee)); } } 
Output:
Is e1 object of Employee: true
Operator Precedence:
Operator

Associativity

() (Paranthesis) [] (Array Subscript) .(dot) (Member selection) 
Left to right 
++ (Unary pre/post increment) — (Unary pre/post decrement) ! (Unary negation operator) ~ (Bitwise complement) 
Right to left 
* (Multiplication) / (Division) % (Modulus) 
Left to right 
+ (Addition) – (Subtraction) 
Left to right 
>> (Right shift) >>> (Zero right shift) << (Left shift) 
Left to right 
> (Greater than) > (Less than) >= (Greater than or equal to) <= (Less than or equal to) 
Left to right 
== (Equal to) != (Not equal to) 
Left to right 
& (Bitwise AND) ^ (Bitwise XOR)  (Bitwise OR) && (Logical AND)  (Logical OR) 
Left to right 
?: (Ternary)  Right to left 
= (Assignment) += (Addition Assignment) = (Subtraction Assignment) *= (Multiplication Assignment) /= (Division Assignment) %= (Modulus Assignment) >>= (Bitwise Right shift Assignment) <<= (Bitwise Left shift Assignment) &= (Bitwise AND Assignment) ^= (Bitwise XOR Assignment) = (Bitwise OR Assignment) 
Right to left 