Operators in Java

Operator in Java is a symbol which is used to perform operations. For example: +, -, *, / etc.

There are many types of operators in Java which are given below:

Unary Operator,
Arithmetic Operator,
Shift Operator,
Relational Operator,
Bitwise Operator,
Logical Operator,
Ternary Operator and
Assignment Operator.

Java Operator Precedence

Operator Type	Category	Precedence
Unary	postfix	`expr++ expr--`
Unary	prefix	`++expr --expr +expr -expr ~ !`
Arithmetic	multiplicative	`* / %`
Arithmetic	additive	`+ -`
Shift	shift	`<< >> >>>`
Relational	comparison	`< > <= >= instanceof`
Relational	equality	`== !=`
Bitwise	bitwise AND	`&`
	bitwise exclusive OR	`^`
	bitwise inclusive OR	`\|`
Logical	logical AND	`&&`
Logical	logical OR	`\|\|`
Ternary	ternary	`? :`
Assignment	assignment	`= += -= *= /= %= &= ^= \|= <<= >>= >>>=`

Unary Operator

The Java unary operators require only one operand. Unary operators are used to perform various operations i.e.:

incrementing/decrementing a value by one
negating an expression
inverting the value of a boolean

Example #1

snippet

class OperatorExample{
public static void main(String args[]){
int x=10;
System.out.println(x++);//10 (11)
System.out.println(++x);//12
System.out.println(x--);//12 (11)
System.out.println(--x);//10
}}

Output

10 12 12 10

Example #2

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=10;
System.out.println(a++ + ++a);//10+12=22
System.out.println(b++ + b++);//10+11=21

}}

Output

22 21

Example #3

Java Unary Operator Example: ~ and !

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=-10;
boolean c=true;
boolean d=false;
System.out.println(~a);//-11 (minus of total positive value which starts from 0)
System.out.println(~b);//9 (positive of total minus, positive starts from 0)
System.out.println(!c);//false (opposite of boolean value)
System.out.println(!d);//true
}}

Output

-11 9 false true

Arithmetic Operators

Java arithmatic operators are used to perform addition, subtraction, multiplication, and division. They act as basic mathematical operations.

Example #1

Java Arithmetic Operator Example

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=5;
System.out.println(a+b);//15
System.out.println(a-b);//5
System.out.println(a*b);//50
System.out.println(a/b);//2
System.out.println(a%b);//0
}}

Output

15 5 50 2 0

Example #2

Java Arithmetic Operator Example: Expression

snippet

class OperatorExample{
public static void main(String args[]){
System.out.println(10*10/5+3-1*4/2);
}}

Output

Shift Operator

Left Shift Operator

The Java left shift operator << is used to shift all of the bits in a value to the left side of a specified number of times.

Example #1

Java Left Shift Operator Example

snippet

class OperatorExample{
public static void main(String args[]){
System.out.println(10<<2);//10*2^2=10*4=40
System.out.println(10<<3);//10*2^3=10*8=80
System.out.println(20<<2);//20*2^2=20*4=80
System.out.println(15<<4);//15*2^4=15*16=240
}}

Output

40 80 80 240

Right Shift Operator

The Java right shift operator >> is used to move left operands value to right by the number of bits specified by the right operand.

Example #2

snippet

class OperatorExample{
public static void main(String args[]){
System.out.println(10>>2);//10/2^2=10/4=2
System.out.println(20>>2);//20/2^2=20/4=5
System.out.println(20>>3);//20/2^3=20/8=2
}}

Output

2 5 2

Example #3

Shift Operator Example: >> vs >>>

snippet

class OperatorExample{
public static void main(String args[]){
	//For positive number, >> and >>> works same
	System.out.println(20>>2);
	System.out.println(20>>>2);
	//For negative number, >>> changes parity bit (MSB) to 0
	System.out.println(-20>>2);
	System.out.println(-20>>>2);
}}

Output

5 5 -5 1073741819

Bitwise Operator

Java AND Operator Example: Logical && and Bitwise &

The logical && operator doesn't check second condition if first condition is false. It checks second condition only if first one is true.

The bitwise & operator always checks both conditions whether first condition is true or false.

Example #1

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=5;
int c=20;
System.out.println(a

Output

false false

Example #2

Java AND Operator Example: Logical && vs Bitwise &

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=5;
int c=20;
System.out.println(a

Output

false 10 false 11

Example #3

OR Operator Example: Logical || and Bitwise |

The logical || operator doesn't check second condition if first condition is true. It checks second condition only if first one is false.

The bitwise | operator always checks both conditions whether first condition is true or false.

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=5;
int c=20;
System.out.println(a>b||ab|ab||a++b|a++

Output

true true true 10 true 11

Ternary Operator

Java Ternary operator is used as one liner replacement for if-then-else statement and used a lot in Java programming. it is the only conditional operator which takes three operands.

Java Ternary Operator Example

Example #1

snippet

class OperatorExample{
public static void main(String args[]){
int a=2;
int b=5;
int min=(a

Output

Another Example:

Example #2

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=5;
int min=(a

Output

Assignment Operator

Java assignment operator is one of the most common operator. It is used to assign the value on its right to the operand on its left.

Example #1

snippet

class OperatorExample{
public static void main(String args[]){
int a=10;
int b=20;
a+=4;//a=a+4 (a=10+4)
b-=4;//b=b-4 (b=20-4)
System.out.println(a);
System.out.println(b);
}}

Output

14 16

Example #2

snippet

class OperatorExample{
public static void main(String[] args){
int a=10;
a[+=3;//10+3
Sy[stem.out.println(a);
a-=[4;//13-4
Syst[em.out.println(a);
a*=2[;//9*2
Syste[m.out.println(a);
a/=2;/[/18/2
System[.out.println(a);
}}

Output

13 9 18 9

Example #3

Assignment Operator Example: Adding short

snippet

class OperatorExample{
public static void main(String args[]){
short a=10;
short b=10;
//a+=b;//a=a+b internally so fine
a=a+b;//Compile time error because 10+10=20 now int
System.out.println(a);
}}

Output

Compile time error

After type cast:

snippet

class OperatorExample{
public static void main(String args[]){
short a=10;
short b=10;
a=(short)(a+b);//20 which is int now converted to short
System.out.println(a);
}}

Output