Java Operators

Introduction

The formula that is capable of performing an operation using one or more of the operands is said to have an operator. Let's use the formula 15 + 9 = 24 as an example. Here, the operands are 15 and 9, and the operator is denoted by " + ". In some circumstances, we can utilize operators for both one and more than two operands. We'll be discussing about Java operators in this section.

In-depth explanations of operators and their types are provided in this article, along with examples of how to use them.

What Is Java Operators ?

An operator is a symbol that instructs the compiler to do a specific operation. Java includes a large number of operators for dealing with various types of operations. When doing arithmetic operations, we utilize the plus (+) operator for addition, multiply(*) for multiplication, and so on.

In Java, an operator is a symbol that is used to execute operations. Operators are constructs that can change the values of operands.

Different Types Of Java Operators

The types below informs us about the whole different types of operators offered by the Java programming language.

1. Unary Operators

2. Arithmetic Operators

3. Relational Operators

4. Logical Operators

5. Bitwise Operators

6. Assignment Operators

7. Shift Operators

8. Ternary Operators

Crack your next tech interview with confidence!

Unary Operatos

In Java, unary operators require a single operand. They are used for increment and decrement values as well as to negotiate a value. Unary operators can also be used to reverse a Boolean value. The table below depicts various unary operators and what they perform.

Program to Understand Unary Operators in Java:

public class Main {
public static void main ( String[] args ) {  
int x = 5;  
boolean y = true;
// post-increment operator
System.out.println ( x++ );
// pre-increment operator
System.out.println ( ++x );
// post-decrement operator
System.out.println ( x-- );  
// pre-decrement operator
System.out.println ( --x );

System.out.println ( !y );
}
}

Output

5
7
7
5
false

The ++ and -- operators are used as prefixes in the program mentioned above (++x, --y). These operators (x++, y++) can be used as postfix as well.

When these operators are used as prefixes vs postfixes, there is a small variation.

Arthematic Operatos

In Java, multiplicative and additive operations such as addition, subtraction, multiplication, division, and modulus are performed via arithmetic operators. The table below describes various arithmetic operators and what they perform.

Note- The answer is a floating point number when an integer and a floating point number are utilized as operands in a single arithmetic operation.
The % operator is most often used with integers.

Program to Understand Arithmetic Operators in Java:

public class Main
{
    public static void main (String[]args)
    {
        int x = 5;
        int y = 10;
        // addition operator
        System.out.println (x + y);
        
        // substraction operator
        System.out.println (x - y);
        
        // multiplication operator
        System.out.println (x * y);
        
        // division operator
        System.out.println (x / y);
        
        // modulus operator
        System.out.println (x % y);
    }
}

Output

15
-5
50
0
5

Relational Operatos

Java uses relational operators to examine relationships between two operands.Decision-making and looping both require relational operators. Different relational operators are included in the table below along with what they perform.

Program to Understand Relational Operators in Java:

public class Main 
{
    public static void main ( String[] args ) 
    {
        int  x = 5;
        int  y = 10;
        
        System.out.println ( x < y );   // Greater than operator
        System.out.println(  x > y );   // Less than operator
        System.out.println ( x <= y );  // Less than or equal to operator
        System.out.println (x >= y );   // Greater than or equal to operator
        System.out.println ( x == y );  // Not Equal to operator
        System.out.println ( x != y );  // Equal to operator
    }
}

Output

true
false
true
false
false
true

Logical Operatos

Java uses logical operators to execute out logical AND, OR, and NOT operations. The functions of the various logical operators are listed in the table below.

Program to Understand Logical Operators in Java:

public class Main 
{
    public static void main ( String[] args ) 
    {
    
    System.out.println((10 > 5) && (15 > 10));  // Logical NOT operator
    System.out.println((10 > 5) && (15 < 10));  
    
    System.out.println((10 < 5) || (15 > 10));  // Logical OR operator
    System.out.println((10 < 5) || (15 < 10));  

    
    System.out.println(!(10 == 5));             // Logical NOT operator
    System.out.println(!(10 > 5));  
  }
}

How Relational Operator Work

1. (10 > 5) && (15 > 10) returns true as both (10 > 5) and (15 > 10) are true.

2. (10 > 5) && (15 < 10) returns false as the expression (15 < 10) is false.

3. (10 < 5) || (15 > 10) returns true as the expression (15 > 10) is true.as

4. (10 < 5) || (15 < 10) returns false as both (10 < 5) and (15 < 10) are false.

5. !(10 == 5) returns true as 10 == 5 is false.

6. !(10 > 5) returns false as 10 > 5 is true.

Output

true
false
true
false
true
false

If and only if both of the Expressions are true, we know that the outcome of the logical AND operator on two Expressions evaluates to true. Therefore, there is no need to evaluate the second Expression if any of the Expression evaluate false.

Exp1 && Exp2

The second Expressions Exp2 is not examined if the first Expression Exp1 evaluates to false.

Bitwise Operatos

Bitwise Operators are operators that work instantly on bits. On our computers, numbers are often represented as bits: a series of zeros and ones. They are utilized when operations on individual bits are required. It works with any integer type.

Example

Assume x = 45 and y = 22 in binary form, as shown below.

x = 0010 1101

y = 0001 0110

Lets see how Bitwise works,

x&y = 0000 0100

x|y = 0011 1111

x^y = 0011 1011

~x = 0011 0001

Program to Understand Bitwise Operators in Java:

public class Main 
{
    public static void main( String[] args ) 
    {
        int x = 45; 
        int y = 22; 
        
        System.out.println ( x&y );  // Bitwise AND operator
       	System.out.println ( x|y );  // Bitwise OR operator
        System.out.println ( x^y );  // Bitwise XOR operator
        System.out.println ( ~x );   // Bitwise Not operator
	}
}

Output

4
63
59
-46

Assignment Operatos

The assignment operator is used to change the value of a variable. The assignment operator's left side operand is known as variable, and the assignment operator's right side operand is known as value.

Program to Understand Assignment Operators in Java:

public class Main 
{
    public static void main ( String[] args ) 
    {
        int x = 5;
        int y = 10;
        int z;
        
        System.out.println ( z = x + y );   //Simple assignment
        System.out.println ( y += x );      //Add AND assignment
        System.out.println ( y -= x);       //Subtract AND assignment
        System.out.println ( y *= x );      //Multiply AND assignment
        System.out.println ( y /= x );      //Divide AND assignment
        System.out.println ( y %= x );      //Modulus AND assignment
        System.out.println ( y ^= x );      //Bitwise exclusive OR and assignment
    }
}

Output

15
15
10
50
10
0
5

Shift Operatos

The assignment operator is used to change the value of a variable. The assignment operator's left side operand is known as variable, and the assignment operator's right side operand is known as value.

Program to Understand Shift Operators in Java:

public class Main
{
    public static void main (String[]args)
    {
        int a = 10;
        System.out.println (a << 2);  //left shift
        System.out.println (a >> 2);  //right shift
    } 
}

Output

40
2

Ternary Operatos

The ternary operator in Java reduces and mimics the if else expression. It's made up of a condition and a question mark (?). It has two expressions that are separated by a colon (:). If the condition is true, the first expression is executed; otherwise, the second expression is executed.

Syntax

variable x = (condition) ? Exp1 (if condition is true) : Exp2( if condition is false)

The value returned by either expression is stored in variable.

Program to Understand Ternary Operators in Java:

public class Main 
{  
    public static void main ( String args[] ) 
    {  
        int x = 10;  
        int y = 5;  
        int greater = ( x > y ) ? x : y;  
        System.out.println ( "The greater value is : " + greater );  
    }
}  

Output

The greater value is : 10

Misc Operatos

instanceof Operator

It's solely used for object reference variables. It determines whether or not the object is of the interface or class type.

Syntax

( Object reference variable ) instanceof  (class/interface type)

The value returned by either expression is stored in variable.

Program to Understand Ternary Operators in Java:

public class Main 
{
    public static void main(String args[]) 
    {

      String name = "Logicmojo";

      // if string name will be same, it will return true
      boolean practice = name instanceof String;
      System.out.println( "The condition is " + practice );
   }
} 

Output

The condition is true   

Precedence & Association of Java Operators

When an expression contains several operators, Java offers well-defined rules for establishing the order in which the operators in the expression are evaluated. Multiplication and division, for example, take precedence over addition and subtraction. Explicit parentheses can override precedence rules. When addressing composite problems containing a maximum of one type of operator, precedence and associative principles are applied. As there might be many possible valuations for the same equation, these principles determine which component of the equation to analyze first.

Precedence of Operators

If there are many operators with different precedence, operator precedence decides which operator is performed first in an expression.

For example, x + y * z is calculated as x + (y * z), whereas x * y + z is calculated as (x * y) + z , because multiplication takes precedence over addition,

Associativity of Operators

When two operators in an expression have the same precedence, operator associativity is utilized.

For example, the compiler will evaluate an expression such as x=y=z=1 as (x=(y=(z=1))).

The terms are linked together through association. Some operators, however, do not have an order of relationship. These are referred to as non-associative operators. Associativity is classified into two types: left to right and right to left.

Advantages and Disadvantages of Operators in Java

Advantages of Operators in Java:

1. Simplified Expression: Operators allow developers to perform complex computations and operations using simple and concise expressions. This simplifies the code and makes it more readable.

2. Efficient Data Manipulation: Operators provide efficient ways to manipulate data, such as performing arithmetic calculations, logical operations, and bit manipulations. This leads to optimized code execution.

3. Enhanced Productivity: Java operators enable developers to write code more efficiently, reducing the number of lines required for a task. As a result, it increases overall productivity during the development process.

4. Flexibility in Logic Building: Java operators offer various logical and conditional operators, which allow developers to create flexible and sophisticated decision-making structures within their programs.

5. Increment and Decrement Operations: The increment (++) and decrement (--) operators are particularly useful for loops and control structures. They simplify the process of updating variables in iterations.

6. Comparisons and Conditions: Relational operators (e.g., <, >, ==, !=) enable easy comparisons between variables, which are essential for decision-making and branching in Java programs.

7. Bitwise Manipulation: Bitwise operators (e.g., &, |, ^) facilitate low-level bit manipulation, which is valuable for tasks such as working with flags, setting/clearing specific bits, and other bitwise operations.

Disadvantages of Operators in Java:

1. Potential for Error: Misusing operators or using incorrect operands can lead to logical errors or unexpected behavior in the program. Developers need to be cautious when working with operators to avoid unintended consequences.

2. Code Complexity: While operators can simplify expressions, complex expressions that involve multiple operators may lead to code that is hard to understand and maintain. It's essential to strike a balance between simplicity and complexity.

3. Division by Zero: Division operators (/ and %) can lead to runtime errors if the denominator is zero. Developers must handle such cases by adding appropriate checks to avoid exceptions.

4. Bitwise Confusion: Bitwise operators can be tricky to understand for those not familiar with low-level bit manipulation. Using these operators without a clear understanding may lead to unintended results.

5. Type Conversion Issues: Certain operators may perform implicit type conversions, which can lead to data loss or unexpected results. Developers need to be aware of type casting rules to avoid such issues.

Conclusions

We covered the different types of Java Operators in this article. The operators are a significant component of Java and are required to conduct various data operations. In Java, there are many different sorts of operators, each with its own specialized purpose. While some operators are more commonly used than others, they can all be beneficial in the correct situation. Anyone can learn to use Java operators with a little effort.

Good luck and happy learning!

Frequently Asked Questions (FAQs)