Operator In Java

Operator In Java: Java is an object-oriented programming language that provides a variety of operators to manipulate and perform operations on values and variables. Operators in Java are symbols or keywords used to perform various operations such as arithmetic, logical, relational, bitwise, and assignment.

These operators play a crucial role in developing complex applications in Java by providing a way to interact with data and manipulate it to produce the desired results. Understanding the various operators in Java and how they work is essential for any Java programmer to develop efficient and effective programs. In this response, we will explore the different types of operators in Java and their functionality.

What is the Operator or Operator In Java?

An operator is a symbol that performs some operation. An operator acts on some variables called operands to get the desired result. According to the implementation, there are different types of the operator are there like:

• Unary Operator: If an operator acts on a single variable, then that is called a unary operator.
• Binary Operator: If an operator acts on two variables, then that is called a binary operator.
• Ternary Operator: If an operator acts on 3 variables, then that is called a ternary operator.

Also, in Java programming language, different types of operators are there according to the classification. Below we have mentioned the different types of operators based on their classification:

Unary Operator In Java

As the name indicates, unary operators act on only one operand. These operators are mainly used for the increment, decrement, or negative value of primitive data type variables.

–: Unary minus is used when you want to assign a negative value.
+: Unary plus, This is used when you want to convert a negative value to a positive value.
+ +: Increment operator, You can use this operator when you want to increment the value by 1. There are two varieties of increment operators, those are:

• Post-Increment: In this case, the value is first used for the operator, and after that, the value is updated by 1.
• Pre-Increment: In this case, the value is first incremented by 1, then its computing use.

— Decrement operator: This acts the same as the increment operator, but where the value is decremented by 1. It also has two varieties, that are:

• Post-decrement: Current value is used for computing, and later, the value is decremented by 1.
• Pre-Decrement: Here First value is decrement by one later compute is done.

!: Logical not operator: This is used to invert the boolean type value. If the current value is true, the operator inverts that value to false and vice versa.

Example Program:

public class UnaryOperatorsEx 
{
   public static void main(String[] args) 
   {
      int a = 11, b = 22, c = 33, d = 44; 
      boolean condition = true; 

      System.out.println(" Current Value Of A = " + a);
      System.out.println(" Current Value Of B = " + b);
      System.out.println(" Current Value Of C = " + c);
      System.out.println(" Current Value Of D = " + d);

      // pre-increment operator
      System.out.println("Value of A after Pre Increment = " + (++a)); 
      System.out.println(" Current Value Of A = " + a);

      // post increment operator 
      System.out.println("Value of B After Post Increment = " + (b++)); 
      System.out.println(" Current Value Of B = " + b);

      // pre-decrement operator 
      System.out.println("Value of C Pre Decrement = " + (--c)); 
      System.out.println("Current Value of C = " + c); 

      // post-decrement operator 
      System.out.println("Value of D after post decrement = " + (d--)); 
      System.out.println("Current Value of D = " + d); 

      // Logical not operator 
      System.out.println("Value of !condition ="+ !condition); 
   }
}

Arithmetic Operator

These operators are used to perform fundamental arithmetic operations like addition, subtraction, etc., on the primitive data types. There are five arithmetic operators in Java, and here is the list:

• *: Multiplication
• /: Division
• %: Modulo
• +: Addition
• –: Subtraction

Since these operators act upon two operands at a time, that’s why these are called binary operators.

Example Program:

public class Operators 
{
   public static void main(String[] args) 
   {
      // TODO Auto-generated method stub
      int a = 11, b = 22; 
      String string1 = "Software", string2 = "Testingo"; 

      // + and - operator 
      System.out.println("a + b = " + (a + b)); 
      System.out.println("a - b = " + (a - b)); 

      // + operator if used with strings 
      System.out.println(" USe of + Operator With String " + string1 + string2); 

      // * and / operator 
      System.out.println("a * b = " + (a * b)); 
      System.out.println("a / b = " + (a / b)); 

      // modulo operator gives remainder 
      // on dividing first operand with second 
      System.out.println("a % b = " + (a % b)); 
   }
}

Relational Operator In Java

These operators are used to compare two variables. For example, to know which is bigger or whether two quantities are equal. There are six relational operators are available:

• ==, Equal to:- returns true if both variables have the same value.
• != Not Equal to– returns true if both the variable doesn’t have the same value.
• <, less than:- returns true of the left-hand side is less than the right-hand side.
• <=, less than or equal to Returns true of the left-hand side is less than or equal to the right-hand side.
• > Greater than returns true of the left-hand side is higher than the right-hand side.
• >=, Greater than or equal to returns true of the left-hand side is greater than or equal to the right-hand side.

Example Program:

public class RelationalOperatorsEx 
{
   public static void main(String[] args) 
   {
      int a = 20, b = 10; 
      String x = "SoftwareTestingo", y = "SoftwareTestingo";
      int array1[] = { 1, 2, 3 }; 
      int array2[] = { 1, 2, 3 }; 
      boolean condition = true; 

      // various conditional operators 
      System.out.println("a == b :" + (a == b)); 
      System.out.println("a < b :" + (a < b)); 
      System.out.println("a <= b :" + (a <= b)); 
      System.out.println("a > b :" + (a > b)); 
      System.out.println("a >= b :" + (a >= b)); 
      System.out.println("a != b :" + (a != b)); 

      // Arrays cannot be compared with 
      // relational operators because objects 
      // store references not the value 
      System.out.println("x == y : " + (array1 == array2)); 

      System.out.println("condition==true :"+ (condition == true));  
   }
}

Output:

a == b :false
a < b :false
a <= b :false
a > b :true
a >= b :true
a != b :true
x == y : false
condition==true :true

Logical Operator In Java

Logical operators are used to construct compound conditions. A compound condition is a combination of several simple conditions. Logical operators are of 3 types:

• && and operator
• || or operator
• ! not operator

Example Program:

import java.util.Scanner;
public class LogicalOperatorsEx 
{
   public static void main(String[] args) 
   {
      String x = "software"; 
      String y = "testingo"; 

      Scanner s = new Scanner(System.in); 
      System.out.print("Enter username:"); 
      String uuid = s.next(); 
      System.out.print("Enter password:"); 
      String upwd = s.next(); 

      // Check if user-name and password match or not. 
      if ((uuid.equals(x) && upwd.equals(y)) || (uuid.equals(y) && upwd.equals(x))) 
      { 
         System.out.println("Welcome user."); 
      } 
      else { 
         System.out.println("Wrong uid or password"); 
      } 
   }
}

Output:

Enter username:software
Enter password:testingo
Welcome user.

Boolean Operator In Java

These operators act on the boolean variables and produce boolean-type results. There are three boolean operators. Are there

• & boolean and operator
• | boolean or operator
• ! boolean not operator

Boolean & operator returns true if both the values of the variables are true. The boolean | operator returns true if any one of the variables is true. Boolean! The operator converts true to false and vice versa.

Bitwise operator In Java

There are seven types of bitwise operators. let’s discuss one by one

• Bitwise Complement Operator (~): This operator gives the complement form of a given number. This operator symbol is ~, which is pronounced as a tilde.
• Bitwise and operator (&): This operator operates on the individual bits of the numbers. The symbol for this operator is &, which is called an ampersand.
• Bitwise Or operator (|): This operator performs or operation on the bits of the numbers. The symbol is |, which is called a pipe symbol.
• Bitwise Xor operator (^): This operator performs exclusive or (Xor) operations on the bits of the numbers. The symbol is ^, a cap, carat, or circumflex symbol.
• Bitwise left shift operator(<<): This operator shifts the bits of the number towards the left in a specified number of positions. The symbol for this operator is <<, read as double less than. If we write x<<n, the meaning is to shift the bits of x towards left n positions.
• Bitwise right shift operator (>>): This operator shifts the bits of the number towards the right in a specified number of positions. The symbol for this operator is >>, read as double greater than. If we write X>>n, the meaning is to shift the bits of x towards the right n positions.
• Bitwise Zero-fill right shift operator(>>>): This operator also shifts the bits of the number toward the right in a specified number of positions. But it stores 0 in the sign bit. The symbol of this operator is >>>, read as triple greater than. Since it always fills 0 in the sign bit, it is called a zero-fill right shift operator. If we apply >>> on a positive number, it gives the same output as that of >>. But in the case of negative numbers, the output will be positive since the sign bit is replaced by a 0.

Ternary operator Java or conditional operator (? :):

This operator is called ternary because it acts on three variables. The other name of this operator is a conditional operator since it represents a conditional statement. Two symbols used for this operator? And.

Variable = expressions1 ? expressions2 expressions3;

This means that, first of all, expression 1 was evaluated. If it is true, the expressions2 value is stored in the variable. If expressions1 is false, the expressions3 value is stored in the variable.

Member Operator (.): A member operator is also called a dot operator since its symbol is a. (dot or period). This operator tells about a member of a package or a class. It is used in three ways.

We know that a package contains classes. We can use it — the operator to refer to the package class.
Syntax:

Packagename.classname

We know that each class contains variables and methods. We can use this operator to refer to a class’s variable.
Syntax:

Classname.variablename; or object name.variablename;

We know that a class contains methods. Using the dot operator, we can refer to the methods of a class.
Syntax:

classname.methodname; or objectname.methodname;

The instance of Operator In Java

This operator is used to test whether an object belongs to the class. Note that the word instance means object. This operator can also be used to check whether an object belongs to an interface.

Syntax:

boolean variable = object instanceof class; 
boolean variable = object instanceof interface;

If the object is an instanceof of a class or interface, it returns true. Otherwise, it returns false.

New Operator: New operator is often used to create objects to classes. We know that JVM dynamically creates objects on heap memory (at runtime).
Syntax:

classname obj= new classname();

Cast Operator:

Cast operators are used to convert one data type to another data type. This operator can be used by writing datatype inside simple braces.

The Priority of Operator In Java

When several operators are used in a statement, knowing which operator will execute first and which will come next is important. To determine that certain rules of operator precedence followed:

• First, the contents inside the braces: () and [] will be executed
• Next, ++ and —
• Next, *,/ and % will execute
• + and – will come next
• Relational operator and executed next
• Boolean and bitwise operators
• Logical operators will come afterward
• Then ternary operator
• Assignment operators are executed at the last

If you find anything wrong or want to share more information on this topic, you can write to us in the comment section.