Operators in Java

Contents

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

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 non-zero 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 vice-versa.	!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 bit-by-bit 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.
- A|B = 0111, In decimal A|B = 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 = C-A
*= (Multiplies, then assigns)	It multiplies the right operand with the left operand and assigns the result to the left operand	C = A means C = CA
/= (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.

Previous Item Next Item

Operators in Java

What are the Operators?

Types of Operators in Java:

Arithmetic Operators:

Relational Operators:

Logical Operators:

Bitwise Operators:

Assignment Operators

Ternary Operator (Conditional Operator):

Special Operators:

Dot Operator (.):

The instanceof Operator:

Related

Get In Touch

Site Links