Operators in Java
What are the Operators?
Programs perform various tasks through the instructions given to them. These commands or instructions contain various symbols that denote specific functions. These symbols are called Operators. Let us learn about Operators in Java in this article!
Operators are specific symbols that specify various mathematical or logical instructions used to manipulate the data in a program.
To learn about the operators from video tutorials, refer to this video:
Types of Operators in Java:
Java supports many operators just like C and C++. Operators are divided into 3 categories depending upon the number of operands they work on.

 Unary Operator
 It operates on only 1 operand
 For example: ++, –, !, ~
 Binary Operators
 It operates on 2 operands
 For example: &&, %, /, 
 Conditional/Ternary Operator
 It operates on 3 operands
 Unary Operator
These unary and binary operators perform different functions. And based on these functions, the operators can be further classified into 6 categories. They are:
 Arithmetic Operators
 Relational Operators
 Logical Operators
 Bitwise Operators
 Assignment Operators
 Special Operators
Arithmetic Operators:
 Performs manipulations like simple mathematical addition, subtraction, multiplication
 Assume A and B are 2 integer variables holding values:
 A = 10
 B = 5
Operator  Function  Example 

+ (Addition Operator)  Adds the two operands  A + B > 15 
 (Subtraction Operator)  Subtracts second operand from the first operand  A – B > 5 
* (Multiplication Operator)  Multiplies both the operands  A * B > 50 
/ (Division Operator)  Divides numerator by denominator  A / B > 2 
% (Modulus Operator)  Gives the remainder after an integer division  A % B > 0 
++ (Increment operator)  increases integer value by one  A++ > 11 
 (Decrement operator)  decreases integer value by one  B > 4 
Below is a simple program to display arithmetic operators and their functions.
package mypackage; public class ArithmaticOperators { static int A = 10; static int B = 5; public static void main(String[] args) { System.out.println("Arithmatic Operators !! \n"); // "\n" creates an empty line System.out.println("Addition Operator : " +"A + B = " + (A + B)); System.out.println("Subtraction Operator : " +"A  B = " + (A  B)); System.out.println("Subtraction Operator : " +"B  A = " + (B  A)); System.out.println("Multiplication Operator : " +"A * B = " + (A * B)); System.out.println("Division Operator : " +"A / B = " + (A / B)); System.out.println("Modulus Operator : " +"A % B = " + (A % B)); A++ ; //A is incremented to 11 System.out.println("Value of A after increment : "+ A); B; System.out.println("Value of B after increment : "+ B); } }
Output:
Relational Operators:
 These are used to comparing two data values or two quantities.
 They are also called as Comparison operators.
 It returns a boolean value based upon the condition. If the condition is satisfied, the result is true, else the result is false.
 Assume A and B are 2 integer variables holding values as
 A = 10
 B = 5
Operator  Function  Example 

== (Is equal to)  Checks if the values of two operands are equal or not. If yes, then the condition becomes true  (A == B) is false 
!= (Is not equal to)  Checks if the values of two operands are equal or not. If the values are not equal, then the condition becomes true  (A != B) is true 
> (Greater than)  Checks if the value of left operand is greater than the value of right operand. If yes, then the condition becomes true  (A > B) is false 
< (Less than)  Checks if the value of left operand is less than the value of right operand. If yes, then the condition becomes true  (A < B) is true 
>= (Greater than or equal to)  Checks if the value of left operand is greater than or equal to the value of right operand. If yes, then the condition becomes true  (A >= B) is false 
<= (Less than or equal to)  Checks if the value of left operand is less than or equal to the value of right operand. If yes, then the condition becomes true  (A <= B) is true 
The program shows the use of relational operators.
package mypackage; public class RelationalOperators { static int A = 10; static int B = 5; public static void main(String[] args) { System.out.println("Relational Operators !! \n"); // "\n" creates an empty line System.out.println("Is equal to Operator : " +"A == B > " + (A == B)); System.out.println("Is not equal to Operator : " +"A != B > " + (A != B)); System.out.println("Greater than Operator : " +"A > B > " + (A > B)); System.out.println("Less than Operator : " +"A < B > " + (A * B)); System.out.println("Greater than or equal to Operator : " +"A >= B > " + (A >= B)); System.out.println("Less than or equal to Operator : " +"A <= B > " + (A <= B)); } }
Output:
Logical Operators:
 These help to checks multiple conditions.
 The result depends upon the validity of the individual conditions as well as the validity of the combined statement.
 They return a boolean value i.e. true or false.
 Assume A and B are 2 integer variables with values
 A = 10
 B = 5.
Let us define 3 conditions:
 Con1:
 (A > B) is true.
 Con2:
 (A == B) is false.
 Con3:
 (A / B == 2) is true.
Operator  Function  Example 

&& (Logical AND operator)  If both the operands are nonzero or true, then condition becomes true.  Con1 && Con2 gives false 
 (Logical OR Operator)  If any of the two operands is nonzero or true, then condition becomes true.  Con1  Con2 gives true 
! (Logical NOT Operator)  It reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false and viceversa.  !Con1 gives false 
The below program displays the use of logical operators.
package mypackage; public class LogicalOperators { static int A = 10; static int B = 5; public static void main(String[] args) { Boolean Condition1 = (A > B); Boolean Condition2 = (A == B); Boolean Condition3 = (A / B == 2); System.out.println("Condition 1 is "+ Condition1); System.out.println("Condition 2 is "+ Condition2); System.out.println("Condition 3 is "+ Condition3+"\n"); System.out.println("Logical Operators !! \n"); // "\n" creates an empty line System.out.println("Logical AND Operator : (Condition1 && Condition2) " + (Condition1 && Condition2)); System.out.println("Logical AND Operator : (Condition1 && Condition3) " + (Condition1 && Condition3)); System.out.println("Logical OR Operator : (Condition1  Condition2) " + (Condition1  Condition2)); System.out.println("Logical NOT Operator (Condition 1) : " + (!Condition1)); System.out.println("Logical NOT Operator (Condition 2 : " + (!Condition2)); } }
Output
Bitwise Operators:
 It performs operations on individual bits of a number.
 It works bitbybit to give the result.
 The truth tables for & (AND),  (OR), and ^ (XOR) are as follows:
p  q  p & q  p  q  p ^ q 

0  0  0  0  0 
0  1  0  1  1 
1  0  0  1  1 
1  1  1  1  0 
 Assume if
 A = 7;
 B = 3;
 In binary format
 A = 0111
 B = 0011
 Bitwise AND
 It returns bit by bit AND operation of the operands
 A&B = 0011, In decimal A&B = 3
 Bitwise OR
 This operator performs OR operation bit by bit on the operands.
 AB = 0111, In decimal AB = 7
 Bitwise XOR
 Returns bit by bit XOR operation of the operands.
 If both the bits are same, gives 0 else gives 1.
 A^B = 0100, In decimal A^B = 4
 Bitwise NOT
 Inverses each bit of the input operand.
 It converts each 0 to 1 and each 1 to 0.
 ~A = 1000, In decimal ~A = 8
 Binary Left Shift Operator
 The left operand’s bits are moved left by the number of bits specified by the right operand.
 It multiplies the operand by 2^n.
 The power n is equal to the number of bits specified by the right operand.
 A = 0111, In decimal A= 7
 A << 1 = 1110, In decimal A << 1 = 14
 Binary Right Shift Operator
 The left operand’s bits are moved right by the number of bits specified by the right operand.
 It divides the operand by 2^n.
 The power n is equal to the number of bits specified by the right operand.
 A = 0111, In decimal A= 7
 A >> 1 = 0011, In decimal A >> 1 = 3
Assignment Operators
 Assignment operators assign the result of an expression to a variable.
 It is a binary operator.
 The value of the right operand is assigned to the left operand.
Operator  Function  Example 

= (Assign)  Assigns values from right side operands to left side operand  K = 3 A = B 
+= (Increments, then assigns)  It adds the right operand to the left operand and assigns the result to the left operand  C += A means C = C+A 
= (Decrements, then assigns)  It subtracts the right operand from the left operand and assigns the result to the left operand  C = A means C = CA 
*= (Multiplies, then assigns)  It multiplies the right operand with the left operand and assigns the result to the left operand  C *= A means C = C*A 
/= (Divides, then assigns)  It divides the left operand with the right operand and assigns the result to the left operand  C /= A means C = C/A 
%= (Modulus, then assigns)  It takes modulus using two operands and assigns the result to the left operand  C %= A means C = C%A 
Ternary Operator (Conditional Operator):
 It works on 3 operands
 It consists of 2 parts:
Condition ? Expression1 : Expression2
 If Condition is true then it returns value of Expression1 otherwise returns the value of Expression2
The program below displays the use of the conditional operator:
package mypackage; public class TernaryOperator { static int A = 10; static int B = 6; public static void main(String[] args) { int result1; int result2; result1 = (A / B == 2) ? (A  B) : (A + B); System.out.println("Result 1 is : "+result1); result2 = (A / B != 2) ? (A  B) : (A + B); System.out.println("Result 2 is : "+result2); } }
Output:
Special Operators:
Java also supports some special type of operators like:
 Dot Operator
 InstanceOf Operator
Dot Operator (.):
 Dot operator helps to access:
 variable/constant
 method
 Class
 package
 For Example:
java.lang.System.out.println("Hello");
The instanceof Operator:
 This operator checks the existence of an object and returns a boolean value.
 It is also called a type/object comparison operator.
 it compares if the object belongs to the specified type.
 Applying the instanceof operator with any object having a null value, returns false.
 It can also identify objects of derived and inherited classes.
The below program explains the use of the instanceof operator.
package mypackage; public class CheckInstance { public static void main(String[] args) { CheckInstance ob = new CheckInstance(); CheckInstance object = null; System.out.println("ob instanceof CheckInstance :"+(ob instanceof CheckInstance)); System.out.println("object instanceof CheckInstance"+(object instanceof CheckInstance)); } }
Output:
In the next article, I will discuss looping control in Java. The article will cover different loops available in Java and how to use them.