An **operator** in Java is a symbol with which we can perform **operations** on the operand. An **operand** may be a variable or a value. For any operation, we must have a minimum of 1 operand.

## Types of Operators in Java

Below are the different types of Operators in Java

### Arithmetic Operators in Java

We use Arithmetic operators in Java to perform **Arithmetic operations** like addition, subtraction, multiplication, division. To perform all these operations, we require **2 operands** on either side of the operator.

Operator | Operation | Syntax |
---|---|---|

+ | Addition | a+b |

- | Subtraction | a-b |

* | Multiplication | a*b |

/ | Division | a/b |

% | Modulo - To find the reminder | a%b |

#### Arithmetic Operator Example

In the below example, we can see that in every expression we use 2 operands to perform arithmetic operations. In this case, a and b are called operands and the symbol between the operands is the operator.

public class ArithmeticOperators { public static void main(String[] args) { int a = 10; int b = 20; int sum = a + b; System.out.println("Sum of a and b is: " + sum); int diff = b - a; System.out.println("Difference between a and b is: " + diff); int prod = a * b; System.out.println("Product of a and b is: " + prod); int div = b/a; System.out.println("Division of a and b is: " + div); int mod = b%a; System.out.println("Reminder of a and b is: " + mod); } }

Sum of a and b is: 30 Difference between a and b is: 10 Product of a and b is: 200 Division of a and b is: 2 Reminder of a and b is: 0

### Unary Operators in Java

This is also another type of arithmetic operator but requires only **1 operand** to perform the operation. Hence its name is Unary operator. This is mainly used for **postfix** and **prefix** operator evaluation. We use it to increment, decrement a value, or negate an expression or invert a boolean value.

Syntax | Operator type | Operation |
---|---|---|

expr++ | Postfix | Increases the value by 1 after the value is assigned |

expr-- | Postfix | Decreases the value by 1 after the value is assigned |

++expr | Prefix | Increases the value by 1 before the value is assigned |

--expr | Prefix | Decreases the value by 1 before the value is assigned |

+expr | Prefix | Displays expression in positive |

-expr | Prefix | Displays expression in negative |

!expr | Prefix | Inverts the value of expression |

#### Unary Operator Example

Let’s understand the unary operators more clearly with the below example. When we execute the expression **a++ **the value of a is still 5 and prints the result as 5 and then increments the value to 6 internally. Hence the first output is 5.

Now, when we execute **a–, **from previous expression value of a is 6, hence it prints 6 and the decrements the value to 5 internally. Hence the second output is 6.

Next, we execute **–a**, which means before it prints it decrements the value by 1 i.e (5-1), Hence the third output is 4.

When we execute **++a**, the value first increments by 1 and then prints the output as 5 i.e(4+1).

public class UnaryOperator { public static void main(String[] args) { int a = 5; System.out.println("Postfix increment:"); System.out.println(a++); System.out.println("Postfix decrement:"); System.out.println(a--); System.out.println("Prefix decrement:"); System.out.println(--a); System.out.println("Prefix increment:"); System.out.println(++a); } }

Postfix increment: 5 Postfix decrement: 6 Prefix decrement: 4 Prefix increment: 5

Next, let’s see how **+** and **–** unary operator works. + gives a positive value if the value is already positive. If the value is negative, it gives a negative value since + and – results in a -. Hence the 1st output is 60 for +b i.e +(+60) = 60 and 2nd output is -55 for +a which means +(-55) = -55.

Similarily, – gives a negative integer value if the value is positive and gives a positive integer if the value is negative. Hence the output is -55 for -b i.e -(60) = -60 and 55 for -a which means -(-55) = 55.

**! (NOT)** operator reverses the boolean value. If the value is true, it returns false and if it’s false it returns true.

public class UnaryOperator { public static void main(String[] args) { int a = -55; int b = 60; Boolean value = false; System.out.println("Positive value:"); System.out.println(+b); System.out.println(+a); System.out.println("Negative value:"); System.out.println(-b); System.out.println(-a); System.out.println("Invert value:"); System.out.println(!value); } }

Positive value: 60 -55 Negative value: -60 55 Invert value: true

### Logical Operators in Java

We use logical operators to evaluate a condition or expression. It may be a single or multiple expression.

Operator | Operation | Syntax |
---|---|---|

&& | Returns true if both expressions are true | (a>b)&&(b<c) where a>b is expression1 and b<c is expression2 |

|| | Returns true if any one expression is true | (a>b) || (b<c) where a>b is expression1 and b<c is expression2 |

! | Reverses the result. Returns true if the expression is false and vice versa | !(a>b) |

#### Logical Operator Example

Logical **AND** returns true only if both the expression values are true. Since the 1st expression (a>10) is false and 2nd expression (b<20) is true, **false AND true returns false** as output.

Logical **OR** returns true is any one of the expression value is true. Here, the output is true since **false OR true returns true**.

Logical **NOT reverse** the boolean value. If the value is false it gives true and vice versa.

public class LogicalOperator { public static void main(String[] args) { int a = 5; int b = 10; Boolean c = (a>10 && b<20 ); System.out.println("Output of Logical AND: " + c); Boolean d = (a>10 || b<20); System.out.println("Output of Logical OR: " + d); System.out.println("Output of Logical NOT: " + !d); } }

Output of Logical AND: false Output of Logical OR: true Output of Logical NOT: false

### Relational Operators in Java

When we want to **compare** two variables or expressions, then we use relational or comparison operators in Java. We mainly use this in evaluating if-else conditions which we will learn in later tutorials.

Operator | Operation | Syntax |
---|---|---|

== | Checks if both variables/expressions are equal | a==b |

!= | Checks if the variables/expressions are not equal to each other | a!=b |

> | Checks which variable or expression is greater | a>b |

< | Checks which variable or expression is lesser | a<b |

>= | Checks which variable or expression is greater than or equal to the other | a>=b |

<= | Checks which variable or expression is lesser than or equal to the other | a<=b |

#### Relational Operator Example

This example shows you how to use relational operators. Here, we are using comparison operators for expression in if-else statements. If the condition is true **if** statement will be executed. If the condition is false, **else** statement will be executed.

public class RelationalOperator { public static void main(String[] args) { int a = 10; int b = 20; if(a==b) System.out.println("a and b are equal"); else System.out.println("a and b are not equal"); if(a>b) System.out.println("a is greater than b"); else System.out.println("b is greater than a"); if(a<b) System.out.println("a is lesser than b"); else System.out.println("b is lesser than a"); if(a!=b) System.out.println("a is not equal to b"); else System.out.println("a is equal to b"); if(a>=b) System.out.println("a is greater than or equal to b"); else System.out.println("a is not greater than or equal to b"); if(a<=b) System.out.println("a is lesser than or equal to b"); else System.out.println("a is not lesser than or equal to b"); } }

a and b are not equal b is greater than a a is lesser than b a is not equal to b a is not greater than or equal to b a is lesser than or equal to b

### Bitwise Operators in Java

These operators perform **bit by bit** operation. The output is either 1 or 0 based on the comparison.

Operator | Operation |
---|---|

& | AND - Returns 1 if both bits are 1 |

| | OR - Returns 1 if any one bit is 1 |

^ | NOT - Inverts the bit |

~ | XOR(Exclusive OR) - Returns 1 if only one of the two bits is 1 |

<< | Shifts left by pushing the bits from right to left and fills with 0 in the end by removing the left most bit |

>> | Shifts right by pushing the copies of the leftmost bit and removes the rightmost bit |

>>> | Shifts right by pushing 0 from left and removes the rightmost bit |

#### Bitwise Operator Example

When we use bitwise operators, the calculation is done by converting the integer to a binary value. Let’s understand this in detail with an example below.

Bitwise AND operator returns 1 if only if both the bits are 1. Hence the below output displays 0 since this condition is not met.

Bitwise OR operator returns 1 if any 1 of the bit is 1. Hence the below output is 7 whose binary value is 0111.

Bitwise XOR operator inverts every bit as you can see in the below illustration.

The left Shift operator shifts the bit from right to left by removing the leftmost bit and adds 0 to the rightmost bit. The number of bits is moved based on the expression. In the below example, the bits are moved by 1 position.

Another way to calculate the left-shift operator is as below. Multiply the integer value with power raised to 2 based on the number of bits.

**a=5**

**a<<1 -> 5*2^1 = 5*2=10**

**a<<2 -> 5*2^2 = 5*4 = 20**

The Right Shift operator shifts the bit from left to right by removing the rightmost bit and adds 0 to the leftmost bit.

Another way to calculate the right-shift operator is as below. Divide the integer value with power raised to 2 based on the number of bits.

**a=5**

**a>>1 -> 5/2^1 = 5/2 = 2**

**a>>2 -> 5/2^2 = 5/4 = 1**

public class BitwiseOperator { public static void main(String[] args) { int a = 5; int b = 2; int val; val = a&b; System.out.println("Output of Bitwise AND: "+ val); val = a|b; System.out.println("Output of Bitwise OR: " + val); System.out.println("Output of Bitwise XOR: " + ~a); System.out.println("Output of RightShift: " + (a>>1)); System.out.println("Output of LeftShift: " + (a<<1)); System.out.println("Output of RightShift with 0: " + (a>>>1)); } }

Output of Bitwise AND: 0 Output of Bitwise OR: 7 Output of Bitwise XOR: -6 Output of RightShift: 2 Output of LeftShift: 10 Output of RightShift with 0: 2

### Assignment Operators in Java

This Operator is used in **assigning value** to a variable based on the required operation.

Operator | Operation | Syntax |
---|---|---|

= | Assigns value from right operand to left operand | a=b |

+= | Add and assigns the result value to the left operand | a+=b is same as a=a+b |

-= | Subtracts and assigns the result value to the left operand | a-=b is same as a=a-b |

*= | Multiplies and assigns the result value to the left operand | a*=b is same as a=a*b |

/= | Divides and assigns the result value to the left operand | a/=b is same as a=a/b |

%= | Performs modulo operation and assigns the result value to the left operand | a%=b is same as a=a%b |

&= | Performs Bitwise AND operation and assigns the result value to the left operand | a&=b is same as a=a&b |

|= | Performs Bitwise OR operation and assigns the result value to the left operand | a|=b is same as a=a|b |

^= | Performs Bitwise exclusice OR operation and assigns the result value to the left operand | a^=b is same as a=a^b |

>>= | Performs Left shift operation and assigns the result value to the left operand | a>>=b is same as a=a>>b |

<<= | Performs Right shift operation and assigns the result value to the left operand | a<<=b is same as a=a<<b |

#### Assignment Operator Example

In the below example, we can see how to use various assignment operators.

public class AssignmentOperaor { public static void main(String[] args) { int x = 5; int y = 10; int i = 3; int j = 2; int a; a=x; System.out.println("a=x: " + a); x+=5; System.out.println("x=x+5: " + x); y-=2; System.out.println("y=y-2: " + y); x*=4; System.out.println("x=x*4: " + x); y/=2; System.out.println("y=y/2: " + y); a%=5; System.out.println("a=a%5: " + a); System.out.println("i=i&j: " + (i&=j)); System.out.println("i=i|j: " + (i|=j)); } }

a=x: 5 x=x+5: 10 y=y-2: 8 x=x*4: 40 y=y/2: 4 a=a%5: 0 i=i&j: 2 i=i|j: 2

### Ternary Operators in Java

This operator displays the result based on the condition. The condition is an expression that returns a boolean value.

**Syntax**

var1 = (expression1) ? value1 : value2

var1 is the variable which holds the result of the operation

expression1 is the expression that evaluates a condition

value1 – Assigns this value as a result to the variable if the expression returns true

value2 – Assigns this value as a result to the variable if the expression returns false

In other words, if the expression is true, the variable holds value1 else holds value2

#### Ternary Operator Example

In the first statement, the output is 100 since the expression returns true and in the 2nd statement, the output is 50 since the expression is false.

public class TernaryOperator { public static void main(String[] args) { int value; int x = 150; int y = 100; value = (x!=y) ? 100:50; System.out.println(value); value = (x<y) ? 100:50; System.out.println(value); } }

100 50

### InstanceOf operator

This is a special operator that checks whether an object belongs to a specific type. Let’s see an example below to understand this better.

public class SpecialOperator { public static void main(String[] args) { String value = "Welcome to Java tutorial"; Boolean b; b = (value instanceof String); System.out.println(b); } }

true

Below is another example of instanceof operator when we have an extended class. Here d is an object of the class Department. But Department class extends College class. Hence d is an instanceof both the class and that’s why we get true as output for both the conditions.

public class Department extends College { public static void main(String[] args) { Department d = new Department(); Boolean b; b = (d instanceof College); System.out.println(b); b = (d instanceof Department); System.out.println(b); } }

true true

When a variable does not have any value assigned which means when it is null, instanceof returns false instead of true.

public class SpecialOperator { public static void main(String[] args) { String value = null; Boolean b; b = (value instanceof String); System.out.println(b); } }

false

## Precedence Of Operators

It is important to understand the precedence of operators when an expression has more than 1 operator. Java evaluates the expression based on the below precedence which shows from high to low.

Operator Type | Operators |

Unary operator | ++(postfix)
— (postfix) ++(prefix) –(prefix) + – ! ~ |

Multiplicative operator | *, /, % |

Additive operator | +, – |

Shift operator | <<
>> >>> |

Relational operator | >
>= < <= |

Equality operator | ==
!= |

Bitwise Operator | &, ^, | |

Logical Operator | &&
|| |

Ternary Operator | ?: |

Assignment Operator | =, +=, -=, *=, /=, %=
>, >=, <, <= &=, ^=, |= |

### Example Program

In the below example, ++ takes the higher precedence, followed by * and then -. Hence we evaluate the expression as below.

++b = 5+1 = 6

++b*c = 6*2 = 12

a-(++b*c) = 15-12 = 3 which is the final output

public class OperatorPrecedence { public static void main(String[] args) { int a = 15; int b = 5; int c = 2; int result; result = (a-++b*c); System.out.println(result); } }

3