Difference Between Right Shift and Unsigned Right Shift or Zero Filled Right Shift

Sandeep Verma — Sun, 19 Jun 2022 16:31:53 +0000

Right Shift and Unsigned Right Shift or Zero Filled Right Shift both are Bitwise operators and work only on integer types. It works with the bits of an integer type values which is typical of 32 bits.

Difference between right shift and unsigned right shift or Zero filled right shift

RIGHT SHIFT	UNSIGNED RIGHT SHIFT
It shifts all bits of a binary number to the right as per the mentioned number of times	It shifts all bits of a binary number to the right by filling zeros at the most significant bit as per the mentioned number of times
Each time when the right shift takes place it divides the binary number by 2, ignoring the remainder	It works by filling zeros on the leftmost most side in the binary representation of an integer
It preserves the sign of negative number or sign extension	It doesn't preserve such sign extension
Most significant bit or leftmost bit filled with previous value in order to maintain signed extension to represent the given integer in positive or negative. if it is one it is negative and if it is zero then it is positive	Most significant bit or leftmost bit filled with 0's, no matter what the initial value was. therefore, it is unsigned shift
It is declared using ">>" symbol. Syntax, num >> n_times	It is declared using ">>" symbol. Syntax, num >>> n_times
It is used to represent a numeric value	It can be used in many situations such as at the time when we work with pixel-based values

Java program to show the working of right shift and unsigned right shift

public class BitwiseOperatorExample {
    public static void main(String[] args) {
        int val = -3;
        int result;
        System.out.println("Input = " + val);
        result = val >> 2;
        System.out.println("Right Shift = " + result);
        result = val >>> 2;
        System.out.println("Unsigned Right Shift = " + result);
    }
}

Output:

Input = -3
Right Shift = -1
Unsigned Right Shift = 1073741823

Working of Right Shift and Unsigned Right Shift With Same Input

Right Shift

Unsigned right shift or Zero filled right shift

What are Operators in Java and its Types With Program Example

Sandeep Verma — Tue, 14 Jun 2022 17:42:55 +0000

Java supports various types of operators and most of these operators are grouped into four categories which are :

Arithmetic operator
Bitwise operator
Relational operator
Logical operator

In this article, we’ll be also discussing some of the special operators used in certain situations:

Assignment Operator
Unary Operator
Ternary Operator
Instance of Operator

An operator is used to perform operations on one, two or three operands, it can be either logical or mathematical operations, forming an expression that gives a new result. For example, a + b, where a and b are operands and + sign is an arithmetic operator.

Arithmetic Operator

Arithmetic operators are used to form a mathematical expression. This formed mathematical expression must consist of numeric operands. It cannot be used on other types such as char or boolean. In other words, it involves addition, subtraction, division and multiplication operations which operates on number operands i.e integer, float, and more.

There are primarily 5 types of arithmetic operators which are + (addition), – (subtraction), / (division), x (multiplication) and % (modulo) operator. Please refer below table for more. Other than that, there are two arithmetic unary operator, namely increment and decrement.

It involves the following operators:

Operators	Operations	Functionality
+	Addition	Add numbers
–	Subtraction	Subtract number
/	Division	Divide number
x	Multiplication	Multiply number
%	Modulus	Get Remainder from division operation
++	Increment	Increment a number by 1
—	Decrement	Decrement a number by 1
+=	Addition Assignment	Add a number to a number at left side of assignment operator
-=	Subtraction Assignment	Subtract a number to a number at left side of assignment operator
/=	Division Assignment	Divide a number to a number at left side of assignment operator
x=	Multiplication Assignment	Multiply a number to a number at left side of assignment operator
%=	Modulus Assignment	Find remainder of division operation with a number to a number at left side of assignment operator

Java Program to show the working of Arithmetic Operator

public class ArithmeticOperator {


public static void main(String[] args) {
int a = 10;
int b = 5;
System.out.println(" Addition = " + (a + b));
System.out.println(" Subtraction = " + (a - b));
System.out.println(" Division = " + (a / b));
System.out.println(" Multiplication = " + (a * b));
System.out.println(" Remainder = " + (a % b));
a++;
System.out.println(" Increment = " + a);
a--;
System.out.println(" Decrement = " + a);
System.out.println(" Addition assignment = " + (a += 6));
System.out.println(" Subtraction assignment = " + (a -= 6));
System.out.println(" Division assignment = " + (a /= 2));
System.out.println(" Multiplication assignment = " + (a *= 2));
System.out.println(" Remainder assignment = " + (a %= 5));
}
}

Output:

Addition = 15
Subtraction = 5
Division = 2
Multiplication = 50
Remainder = 0
Increment = 11
Decrement = 10
Addition assignment = 16
Subtraction assignment = 10
Division assignment = 5
Multiplication assignment = 10
Remainder assignment = 0

Bitwise Operator

It performs all its operations only on integer types. As the name suggests, it works with the bits of an integer type values which is typical of 32 bits.

In other words, All the integer are represented by binary numbers on which bitwise operator works. An integer type can be negative and positive if the most significant bit of a given number represents 0 then it is a positive number or 1 then it is a negative number.

Below are the list of Bitwise operators :

Operator	Operations	Functionality	Example
&	Bitwise AND	It performs AND operations among binary number. It is represented by &	4 = 100 5= 101 4 :- 100 5 :-. &101 Output :- 100
\|	Bitwise OR	It performs OR operations among binary number. It is represented by \|	4 = 100 5= 101 4 :- 100 5 :-. \|101 Output :- 101
~	Bitwise Unary not	It performs ones complement on binary number. It is represented by tilt sign (~)	4 = 0000 …….100 4 :- 0000 …….100 ~ 1st complement = 0000….100 + 1 0000….101 Output = -5
^	Bitwise exclusive OR	It performs exclusive OR operations on binary number. It is represented by ^	4 = 100 5= 101 4 :- 100 5 :-. ^101 Output :- 001
>>	Shift right	It shifts bits of binary number to the right as per the given bits that represents how much to shift	4 = 00100 4 :- 00100 >> 1bit Output :- 00010
<<	Shift left	It shifts bits of binary number to the left as per the given bits that represents how much to shift	4 = 00100 4 :- 00100 << 1bit Output :- 01000
>>>	Shift right Zero fill	It fills 0’s in a binary number from left in order to make a number positive or unsigned	4 = 00100 4 :- 00100 >>> 1bit Output :- 00010
&=	Bitwise AND Assignment	Perform AND operation to a number with the number left side of assignment operator	Similar AND
\|=	Bitwise OR Assignment	Perform OR operation to a number with the number left side of assignment operator	Similar OR
>>=	Shift right Assignment	Perform right shift operation mentioned at right side on a number at left side of assignment operator	Similar Shift right
>>>=	Shift right Zero fill Assignment	Perform unsigned right shift operation and fills 0’s in most significant bits mentioned at right side on a given number at left side of assignment operator	Similar Shift right Zero fill
<<=	Shift left assignment	Perform left shift operation mentioned at right side on a number at left side of assignment operator	Similar Shift left

Java program to show the working of Bitwise operators

public class BitwiseOperator {


public static void main(String[] args) {
int a = 4;
int b = 5;
System.out.println(" AND = " + (a & b));
System.out.println(" OR = " + (a | b));
System.out.println(" Complement = " + (~a));
System.out.println(" XOR = " + (a ^ b));
System.out.println(" Right Shift = " + (a >> 1));
a = 4;
System.out.println(" Left Shift = " + (a << 1));
a = 4;
System.out.println(" Unsigned Right Shift = " + (a >>> 1));

}
}

Output:

AND = 4
OR = 5
Complement = -5
XOR = 1
Right Shift = 2
Left Shift = 8
Unsigned Right Shift = 2

Relational Operator

It is used to define a relationship between two operands by determining their equality and ordering. It always returns a boolean value. It can be mostly seen in loops and If statement.

It includes equality and inequality that can be applied to characters, numeric type and more, whereas ordering operators can only be applied on the numeric type.

Operator	Operations
==	Equality check
!=	Inequality check
>=	Greater than equal to check
<=	Smaller than equal to check
>	Greater than to check
<	Smaller than to check

Java program to show the working of Relational operator

public class RelationalOperator {


public static void main(String[] args) {
int x = 0;
boolean result;
result = x==0;
System.out.println("Equality Operator = "+result);
result = x!=1;
System.out.println("Inequality Operator = "+result);
result = x>=0;
System.out.println("Greater than equal to Operator = "+result);
result = x<=0;
System.out.println("Smaller than equal to Operator = "+result);
result = x<1;
System.out.println("Smaller Operator = "+result);
result = x>-1;
System.out.println("Greater Operator = "+result);


}
}

Output:

Equality Operator = true
Inequality Operator = true
Greater than equal to Operator = true
Smaller than equal to Operator = true
Smaller Operator = true
Greater Operator = true

Logical Operator

It combines two or more relational expressions together in which each expression return a boolean value. These boolean values are the values on which logical operators work and again a true or false is evaluated for decision making.

Operator	Operations	Functionality
&	Logical AND	If condition A and B are evaluated as true then only it returns true
\|	Logical OR	Either A or B is evaluated as true then it would return true
^	Logical XOR ( Exclusive OR)	If condition A evaluates different from B them it would return true. In other words, if A condition returns true then B should be false in order to evaluate true
\|\|	Short-circuit OR	It only evaluates first or left expression, if it returns true then it would return true, without evaluating second or right expression
?:	Ternary if then else	If a condition is evaluated as true, then it would return first statement followed by ? Symbol. Otherwise, second statement would be returned
&&	Short-circuit AND	It evaluates first expression, if it returns true then it would evaluate second condition if it returns true, then final outcome will be true
!	Logical Unary not	If condition A is evaluated as false then it would return true

Java program to show the working of Logical operator

public class LogicalOperator {
public static void main(String[] args) {
int x = 10, y = 20;
System.out.println("AND operator = " + ((x > 9) & (y > 9))); // 10>9 & 20>9, since both are true result is true
System.out.println("OR operator = " + ((x < 9) | (y > 9))); // 10<9 | 20>9, since left one is true result is true
System.out.println("XOR operator = " + ((x < 9) ^ (y > 9))); // 10<9 ^ 20>9, since both are different one is false and other one is true result is true
System.out.println("Short-Circuit AND operator = " + ((x < 9) && (y > 9))); //10<9 && 20>9, only left one is evaluated which is false
System.out.println("Short-Circuit OR operator = " + ((x < 9) && (y > 9))); //10<9 && 20>9, only left one is evaluated which is false
System.out.println("Ternary Operator AND operator = " + ((x > y) ? 1 : 0)); //10>20? 1:0, expression before ? is false, which would return second statement after ? that is 0
System.out.println("Not Equal operator = " + (!(x > y))); // 10>20, since it is false and when this evaluated false again complemented it returns true


}
}

Output:

AND operator = true
OR operator = true
XOR operator = true
Short-Circuit AND operator = false
Short-Circuit OR operator = false
Ternary Operator AND operator = 0
Not Equal operator = true

Assignment Operator

It is used to assign a value to an operand. The operand must be compatible with the type of expression.

It assigns a value of right hand side operand to another operand presenting at left side.

int a =10 ;

Unary Operator

Unary Operator is a single operand operator. It can be defined as an operator that operates on only a single operand and performs operations such as increment, or decrement on a variable. It uses operators ranging from arithmetic to logical to perform operations on individual variables i.e +,-,!.

Operators	Operations	Example
+	Unary Plus provides positive value for the arithmetic operand	+x
–	Unary Minus provides negative value for the arithmetic operand	-x
++	Increment Operator increases the operand value by 1	x= x+1 (pre-increment) : ++x; (post-increment) : x++;
—	Decrement Operator decreases the operand’s value by 1	x=x-1 (pre-decrement) : —x; (post-decrement) : x–;
!	Logical Unary Not negates inverse the operand’s logical value	!x
~	Bitwise Unary Not performs one’s complement on binary number	~x

Java program to show the working of Unary Operator

public class UnaryOperator {
    public static void main(String[] args) {
        int x = 4;
        int result;

        result= -x;
        System.out.println("Unary Minus operator :: "+ result);

        result = +x;
        System.out.println("Unary Plus operator :: "+ result);


        System.out.println("Increment operator :: "+ ++x);

        System.out.println("Decrement operator :: "+ --x);

        System.out.println("Logical Not operator :: "+ !(x < 10));

        System.out.println("Bitwise Not operator :: "+ ~(x));


    }
}

Output:

Unary Minus operator :: -4
Unary Plus operator :: 4
Increment operator :: 5
Decrement operator :: 4
Logical Not operator :: false
Bitwise Not operator :: -5

Ternary Operator

Ternary operator operates on three operands which are conditional expression, truthy statement, and falsy statement. If an expression is turned out to be truthy, statement 1 would be executed otherwise, statement 2 which is falsy, would be executed.

It can be used in place of certain if -then-else statement situation. It is represented by ?: operator.

expression1 ? statement 1 : statement 2

Java program to show the working of ternary operator

public class TernaryOperator {


    public static void main(String[] args) {
        Scanner inputReader = new Scanner(System.in);
        System.out.print("Please enter your age : ");
        int voterAge = inputReader.nextInt();
        String msg = voterAge < 18 ? "you are not eligible" : "You can vote";
        System.out.println(msg);
    }

}

InstanceOf Operator

InstanceOf operator can be defined as an operator that checks whether an object belongs to an instance of a class or not. It is a binary operator that compares instance type, if the given object is equivalent to an instance of a targeted class, it would return true otherwise false. It also applies to subclass and interface.

Java program to show the working of instanceOf operator

public class InstanceOfOperator {

    public static void main(String[] args) {
        Integer x = 10;

        if(x instanceof Number){
            System.out.println("Integer is Subclass of Number class");
        }
    }
}

Output :

Integer is Subclass of Number class

bitwise operator – Programmerbay

Difference Between Right Shift and Unsigned Right Shift or Zero Filled Right Shift