 # Java Bitwise and Shift Operators

In this tutorial, we will learn about the bitwise operator and different types of shift operators in Java with the help of examples.

In Java, bitwise operators perform operations on integer data at the individual bit-level. Here, the integer data includes `byte`, `short`, `int`, and `long` types of data.

There are 7 operators to perform bit-level operations in Java.

Operator Description
`|` Bitwise OR
`&` Bitwise AND
`^` Bitwise XOR
`~` Bitwise Complement
`<<` Left Shift
`>>` Signed Right Shift
`>>>` Unsigned Right Shift

## 1. Java Bitwise OR Operator

The bitwise OR `|` operator returns 1 if at least one of the operands is 1. Otherwise, it returns 0.

The following truth table demonstrates the working of the bitwise OR operator. Let a and b be two operands that can only take binary values i.e. 1 or 0.

a b a | b
0 0 0
0 1 1
1 0 1
1 1 1

The above table is known as the "Truth Table" for the bitwise OR operator.

Let's look at the bitwise OR operation of two integers 12 and 25.

``````12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

Bitwise OR Operation of 12 and 25
00001100
| 00011001
____________
00011101 = 29 (In Decimal)``````

### Example 1: Bitwise OR

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

int number1 = 12, number2 = 25, result;

// bitwise OR between 12 and 25
result = number1 | number2;
System.out.println(result);    // prints 29
}
}``````

## 2. Java Bitwise AND Operator

The bitwise AND `&` operator returns 1 if and only if both the operands are 1. Otherwise, it returns 0.

The following table demonstrates the working of the bitwise AND operator. Let a and b be two operands that can only take binary values i.e. 1 and 0.

a b a & b
0 0 0
0 1 0
1 0 0
1 1 1

Let's take a look at the bitwise AND operation of two integers 12 and 25.

``````12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

// Bitwise AND Operation of 12 and 25
00001100
& 00011001
____________
00001000 = 8 (In Decimal)``````

### Example 2: Bitwise AND

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

int number1 = 12, number2 = 25, result;

// bitwise AND between 12 and 25
result = number1 & number2;
System.out.println(result);    // prints 8
}
}``````

## 3. Java Bitwise XOR Operator

The bitwise XOR `^` operator returns 1 if and only if one of the operands is 1. However, if both the operands are 0 or if both are 1, then the result is 0.

The following truth table demonstrates the working of the bitwise XOR operator. Let a and b be two operands that can only take binary values i.e. 1 or 0.

a b a & b
0 0 0
0 1 1
1 0 1
1 1 0

Let's look at the bitwise XOR operation of two integers 12 and 25.

``````12 = 00001100 (In Binary)
25 = 00011001 (In Binary)

// Bitwise XOR Operation of 12 and 25
00001100
^ 00011001
____________
00010101 = 21 (In Decimal)``````

### Example 4: Bitwise XOR

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

int number1 = 12, number2 = 25, result;

// bitwise XOR between 12 and 25
result = number1 ^ number2;
System.out.println(result);    // prints 21
}
}``````

## 4. Java Bitwise Complement Operator

The bitwise complement operator is a unary operator (works with only one operand). It is denoted by `~`.

It changes binary digits 1 to 0 and 0 to 1.

It is important to note that the bitwise complement of any integer N is equal to - (N + 1). For example,

Consider an integer 35. As per the rule, the bitwise complement of 35 should be -(35 + 1) = -36. Now let's see if we get the correct answer or not.

``````35 = 00100011 (In Binary)

// using bitwise complement operator
~ 00100011
__________
11011100``````

In the above example, we get that the bitwise complement of 00100011 (35) is 11011100. Here, if we convert the result into decimal we get 220.

However, it is important to note that we cannot directly convert the result into decimal and get the desired output. This is because the binary result 11011100 is also equivalent to -36.

To understand this we first need to calculate the binary output of -36.

### 2's Complement

In binary arithmetic, we can calculate the binary negative of an integer using 2's complement.

1's complement changes 0 to 1 and 1 to 0. And, if we add 1 to the result of the 1's complement, we get the 2's complement of the original number. For example,

``````// compute the 2's complement of 36
36 = 00100100 (In Binary)

1's complement = 11011011

2's complement:
11011011
+   1
_________
11011100``````

Here, we can see the 2's complement of 36 (i.e. -36) is 11011100. This value is equivalent to the bitwise complement of 35.

Hence, we can say that the bitwise complement of 35 is -(35 + 1) = -36.

### Example 3: Bitwise Complement

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

int number = 35, result;

// bitwise complement of 35
result = ~number;
System.out.println(result);    // prints -36
}
}``````

## Java Shift Operators

There are three types of shift operators in Java:

• Signed Left Shift (<<)
• Signed Right Shift (>>)
• Unsigned Right Shift (>>>)

## 5. Java Left Shift Operator

The left shift operator shifts all bits towards the left by a certain number of specified bits. It is denoted by `<<`.

As we can see from the image above, we have a 4-digit number. When we perform a 1 bit left shift operation on it, each individual bit is shifted to the left by 1 bit.

As a result, the left-most bit (most-significant) is discarded and the right-most position(least-significant) remains vacant. This vacancy is filled with 0s.

### Example 5: Left Shift Operators

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

int number = 2;

// 2 bit left shift operation
int result = number << 2;
System.out.println(result);    // prints 8
}
}``````

## 5. Java Signed Right Shift Operator

The signed right shift operator shifts all bits towards the right by a certain number of specified bits. It is denoted by `>>`.

When we shift any number to the right, the least significant bits (rightmost) are discarded and the most significant position (leftmost) is filled with the sign bit. For example,

``````// right shift of 8
8 = 1000 (In Binary)

// perform 2 bit right shift
8 >> 2:
1000 >> 2 = 0010 (equivalent to 2)``````

Here, we are performing the right shift of 8 (i.e. sign is positive). Hence, there no sign bit. So the leftmost bits are filled with 0 (represents positive sign).

``````// right shift of -8
8 = 1000 (In Binary)

1's complement = 0111

2's complement:

0111
+ 1
_______
1000

Signed bit = 1

// perform 2 bit right shift
8 >> 2:
1000 >> 2 = 1110 (equivalent to -2)``````

Here, we have used the signed bit 1 to fill the leftmost bits.

### Example 6: Signed Right Shift Operator

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

int number1 = 8;
int number2 = -8;

// 2 bit signed right shift
System.out.println(number1 >> 2);    // prints 2
System.out.println(number2 >> 2);    // prints -2
}
}``````

## 7. Java Unsigned Right Shift Operator

Java also provides an unsigned right shift. It is denoted by `>>>`.

Here, the vacant leftmost position is filled with 0 instead of the sign bit. For example,

``````// unsigned right shift of 8
8 = 1000

8 >>> 2 = 0010

// unsigned right shift of -8
-8 = 1000 (see calculation above)

-8 >>> 2 = 0010``````

### Example 7: UnSigned Right Shift

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

int number1 = 8;
int number2 = -8;

// 2 bit signed right shift
System.out.println(number1 >>> 2);    // prints 2
System.out.println(number2 >>> 2);    // prints 1073741822
}
}``````

As we can see the signed and unsigned right shift operator returns different results for negative bits. To learn more visit the Difference between >> and >>>.