Operators in Java

An operator in Java is a symbol with which we can perform operations on the operand. An operand may be a variable or a value. For any operation, we must have a minimum of 1 operand.

Types of Operators in Java

Below are the different types of Operators in Java

Arithmetic Operators in Java

We use Arithmetic operators in Java to perform Arithmetic operations like addition, subtraction, multiplication, division. To perform all these operations, we require 2 operands on either side of the operator.

Arithmetic Operator Example

In the below example, we can see that in every expression we use 2 operands to perform arithmetic operations. In this case, a and b are called operands and the symbol between the operands is the operator.

public class ArithmeticOperators {

  public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int sum = a + b;
    System.out.println("Sum of a and b is: " + sum);
    
    int diff = b - a;
    System.out.println("Difference between a and b is: " + diff);
    
    int prod = a * b;
    System.out.println("Product of a and b is: " + prod);
    
    int div = b/a;
    System.out.println("Division of a and b is: " + div);
    
    int mod = b%a;
    System.out.println("Reminder of a and b is: " + mod);

  }

}

Sum of a and b is: 30
Difference between a and b is: 10
Product of a and b is: 200
Division of a and b is: 2
Reminder of a and b is: 0

Unary Operators in Java

This is also another type of arithmetic operator but requires only 1 operand to perform the operation. Hence its name is Unary operator. This is mainly used for postfix and prefix operator evaluation. We use it to increment, decrement a value, or negate an expression or invert a boolean value.

Unary Operator Example

Let’s understand the unary operators more clearly with the below example. When we execute the expression a++ the value of a is still 5 and prints the result as 5 and then increments the value to 6 internally. Hence the first output is 5.

Now, when we execute a–, from previous expression value of a is 6, hence it prints 6 and the decrements the value to 5 internally. Hence the second output is 6.

Next, we execute –a, which means before it prints it decrements the value by 1 i.e (5-1), Hence the third output is 4.

When we execute ++a, the value first increments by 1 and then prints the output as 5 i.e(4+1).

public class UnaryOperator {

  public static void main(String[] args) {
    int a = 5;
    
    System.out.println("Postfix increment:");
    System.out.println(a++);
    System.out.println("Postfix decrement:");
    System.out.println(a--);
    System.out.println("Prefix decrement:");
    System.out.println(--a);
    System.out.println("Prefix increment:");
    System.out.println(++a);
    
  }
}

Postfix increment:
5
Postfix decrement:
6
Prefix decrement:
4
Prefix increment:
5

Next, let’s see how + and – unary operator works. + gives a positive value if the value is already positive. If the value is negative, it gives a negative value since + and – results in a -. Hence the 1st output is 60 for +b i.e +(+60) = 60 and 2nd output is -55 for +a which means +(-55) = -55.

Similarily, – gives a negative integer value if the value is positive and gives a positive integer if the value is negative. Hence the output is -55 for -b i.e -(60) = -60 and 55 for -a which means -(-55) = 55.

! (NOT) operator reverses the boolean value. If the value is true, it returns false and if it’s false it returns true.

public class UnaryOperator {

  public static void main(String[] args) {
    int a = -55;
    int b = 60;
    Boolean value = false;
    System.out.println("Positive value:");
    System.out.println(+b);
    System.out.println(+a);
    System.out.println("Negative value:");
    System.out.println(-b);
    System.out.println(-a);
    System.out.println("Invert value:");
    System.out.println(!value);
    
  }
}

Positive value:
60
-55
Negative value:
-60
55
Invert value:
true

Logical Operators in Java

We use logical operators to evaluate a condition or expression. It may be a single or multiple expression.

Logical Operator Example

Logical AND returns true only if both the expression values are true. Since the 1st expression (a>10) is false and 2nd expression (b<20) is true, false AND true returns false as output.

Logical OR returns true is any one of the expression value is true. Here, the output is true since false OR true returns true.

Logical NOT reverse the boolean value. If the value is false it gives true and vice versa.

public class LogicalOperator {

  public static void main(String[] args) {
    int a = 5;
    int b = 10;
    Boolean c = (a>10 && b<20 );
    System.out.println("Output of Logical AND: " + c);
    Boolean d = (a>10 || b<20);
    System.out.println("Output of Logical OR: " + d);
    System.out.println("Output of Logical NOT: " + !d);
    
  }

}

Output of Logical AND: false
Output of Logical OR: true
Output of Logical NOT: false

Relational Operators in Java

When we want to compare two variables or expressions, then we use relational or comparison operators in Java. We mainly use this in evaluating if-else conditions which we will learn in later tutorials.

Relational Operator Example

This example shows you how to use relational operators. Here, we are using comparison operators for expression in if-else statements. If the condition is true if statement will be executed. If the condition is false, else statement will be executed.

public class RelationalOperator {

  public static void main(String[] args) {
    int a = 10;
    int b = 20;
    if(a==b)
      System.out.println("a and b are equal");
    else
      System.out.println("a and b are not equal");
    if(a>b)
      System.out.println("a is greater than b");
    else
      System.out.println("b is greater than a");
    if(a<b)
      System.out.println("a is lesser than b");
    else
      System.out.println("b is lesser than a");
    if(a!=b)
      System.out.println("a is not equal to b");
    else
      System.out.println("a is equal to b");
    if(a>=b)
      System.out.println("a is greater than or equal to b");
    else
      System.out.println("a is not greater than or equal to b");
    if(a<=b)
      System.out.println("a is lesser than or equal to b");
    else
      System.out.println("a is not lesser than or equal to b");
  }

}

a and b are not equal
b is greater than a
a is lesser than b
a is not equal to b
a is not greater than or equal to b
a is lesser than or equal to b

Bitwise Operators in Java

These operators perform bit by bit operation. The output is either 1 or 0 based on the comparison.

Bitwise Operator Example

When we use bitwise operators, the calculation is done by converting the integer to a binary value. Let’s understand this in detail with an example below.

Bitwise AND operator returns 1 if only if both the bits are 1. Hence the below output displays 0 since this condition is not met.

Bitwise OR operator returns 1 if any 1 of the bit is 1. Hence the below output is 7 whose binary value is 0111.

Bitwise XOR operator inverts every bit as you can see in the below illustration.

The left Shift operator shifts the bit from right to left by removing the leftmost bit and adds 0 to the rightmost bit. The number of bits is moved based on the expression. In the below example, the bits are moved by 1 position.

Another way to calculate the left-shift operator is as below. Multiply the integer value with power raised to 2 based on the number of bits.

a=5

a<<1 -> 5*2^1  = 5*2=10

a<<2 -> 5*2^2 = 5*4 = 20

The Right Shift operator shifts the bit from left to right by removing the rightmost bit and adds 0 to the leftmost bit.

Another way to calculate the right-shift operator is as below. Divide the integer value with power raised to 2 based on the number of bits.

a=5

a>>1 -> 5/2^1 = 5/2 = 2

a>>2 -> 5/2^2 = 5/4 = 1

public class BitwiseOperator {

  public static void main(String[] args) {
    int a = 5;
    int b = 2;
    int val;
    
    val = a&b;
    System.out.println("Output of Bitwise AND: "+ val);
    
    val = a|b;
    System.out.println("Output of Bitwise OR: " + val);
    
    System.out.println("Output of Bitwise XOR: " + ~a);
    System.out.println("Output of RightShift: " + (a>>1));
    System.out.println("Output of LeftShift: " + (a<<1));
    System.out.println("Output of RightShift with 0: " + (a>>>1));
    
  }

}

Output of Bitwise AND: 0
Output of Bitwise OR: 7
Output of Bitwise XOR: -6
Output of RightShift: 2
Output of LeftShift: 10
Output of RightShift with 0: 2

Assignment Operators in Java

This Operator is used in assigning value to a variable based on the required operation.

Assignment Operator Example

In the below example, we can see how to use various assignment operators.

public class AssignmentOperaor {

  public static void main(String[] args) {
    int x = 5;
    int y = 10;
    int i = 3;
    int j = 2;
    int a;
    a=x;
    System.out.println("a=x: " + a);
    x+=5;
    System.out.println("x=x+5: " + x);
    y-=2;
    System.out.println("y=y-2: " + y);
    x*=4;
    System.out.println("x=x*4: " + x);
    y/=2;
    System.out.println("y=y/2: " + y);
    a%=5;
    System.out.println("a=a%5: " + a);
    System.out.println("i=i&j: " + (i&=j));
    System.out.println("i=i|j: " + (i|=j));

  }

}

a=x: 5
x=x+5: 10
y=y-2: 8
x=x*4: 40
y=y/2: 4
a=a%5: 0
i=i&j: 2
i=i|j: 2

Ternary Operators in Java

This operator displays the result based on the condition. The condition is an expression that returns a boolean value.

Syntax

var1 = (expression1) ? value1 : value2

var1 is the variable which holds the result of the operation

expression1 is the expression that evaluates a condition

value1 – Assigns this value as a result to the variable if the expression returns true

value2 – Assigns this value as a result to the variable if the expression returns false

In other words, if the expression is true, the variable holds value1 else holds value2

Ternary Operator Example

In the first statement, the output is 100 since the expression returns true and in the 2nd statement, the output is 50 since the expression is false.

public class TernaryOperator {

  public static void main(String[] args) {
    int value;
    int x = 150;
    int y = 100;
    value = (x!=y) ? 100:50;
    System.out.println(value);
    
    value = (x<y) ? 100:50;
    System.out.println(value);
  }

}

100
50

InstanceOf operator

This is a special operator that checks whether an object belongs to a specific type. Let’s see an example below to understand this better.

public class SpecialOperator {

  public static void main(String[] args) {
    String value = "Welcome to Java tutorial";
    Boolean b;
    b = (value instanceof String);
    System.out.println(b);
  }

}

true

Below is another example of instanceof operator when we have an extended class. Here d is an object of the class Department. But Department class extends College class. Hence d is an instanceof both the class and that’s why we get true as output for both the conditions.

public class Department extends College {

  public static void main(String[] args) {
    Department d = new Department();
    Boolean b;
    b = (d instanceof College);
    System.out.println(b);
    b = (d instanceof Department);
    System.out.println(b);
  }

}

true
true

When a variable does not have any value assigned which means when it is null, instanceof returns false instead of true.

public class SpecialOperator {

  public static void main(String[] args) {
    String value = null;
    Boolean b;
    b = (value instanceof String);
    System.out.println(b);
  }

}

false

Precedence Of Operators

It is important to understand the precedence of operators when an expression has more than 1 operator. Java evaluates the expression based on the below precedence which shows from high to low.

Example Program

In the below example, ++ takes the higher precedence, followed by * and then -. Hence we evaluate the expression as below.

++b = 5+1 = 6

++b*c = 6*2 = 12

a-(++b*c) = 15-12 = 3 which is the final output

public class OperatorPrecedence {

  public static void main(String[] args) {
    int a = 15;
    int b = 5;
    int c = 2;
    int result;
    result = (a-++b*c);
    System.out.println(result);

  }

}

3

Reference