---
title: Bitwise Operators in Java - Scaler Topics
description: This article by Scaler Topics will discuss about the case of a sentence and see if the number is even or odd with the help of Bitwise operators.
author: Atul Sharma
category: Java
---

:::section{.abstract}

`Bitwise` operators in Java are among those operators that perform their tasks at a `binary level` directly on `binary digits` (also known as bits), the smallest form of data in a computer or its data types. These `bitwise operators` are faster and an efficient way to interact with computers to make heavy computation in a `linear time` because they work directly with the bits rather than through a `level of abstraction` of software.

The image below shows the steps required to perform arithmetic operations on decimal and binary data.

`Bit Manipulation` is performed using Bitwise Operators in Java on each bit of a number individually and can be used with any data type, such as int, float, short, char, etc.

Bitwise operators work internally on a **binary equivalent of decimal numbers**, i.e. the operation is performed on decimal numbers and internally, these operators work on individual bits `bit by bit`, as per the given operations:
The process begins by converting the operands into binary form. Then, the operator is executed on each binary number, producing the result. Finally, the resulting binary value is converted back into its decimal representation.
Standard arithmetic operators perform operations on human-readable values `(3+4)`, while bitwise operators manipulate the low-level data directly.
:::

:::section{.main}
## Types of Bitwise Operators in Java

There are six types of bitwise operator in Java:

1. Bitwise AND
2. Bitwise inclusive OR
3. Bit Shift Operators
4. Bitwise Compliment
5. Bitwise exclusive OR


| Operators | Symbol | Uses |
| :---: | :---: | :---: |
| Bitwise AND | ``&`` | num1 & num2 |
| Bitwise Exclusive OR (XOR) | ``^`` | num1 ^ num2 |
| Bitwise Inclusive OR | \\| | num1 \\| num2 |
| Bitwise Complement | ``~`` | ~ num |
| Bitwise Left shift | ``<<`` | num1 << num2 |
| Bitwise Right shift | ``>>`` | num1 >> num2 |
| Unsigned Right Shift Operator | ``>>>`` | num1>>>num2 |

Let's go through all these operators one by one.
:::

:::section{.main}
## Bitwise AND(``&``)
`AND (&)` is a important binary operator which compares two binary operands of equal `bit` length. For every `bit`, the operation checks if both bits are `1` across both `operands`. If `true`, `bit` will be set to `1` in the answer. Else, the resulting bit is set to `0`.

Its Truth Table:

1 & 0 => gives 0
0 & 1 => gives 0
0 & 0 => gives 0
1 & 1 => gives 1

**Example:**

We want to perform Bitwise AND Operation of 6 and 8 (6 & 8), then.

a = 6 = 0110 (In Binary)
b = 8 = 1000 (In Binary)

0110
& 1000
________
0000 = 0 (In decimal)

:::

:::section{.main}
## Bitwise OR(``|``)
The OR operaor is denoted by '|'. It perform bitwise (i.e bit by bit) or of input operands, if either of bits is 1 then it will give 1 otherwise it will give 0.

**Its Truth Table:**

1 | 0 => gives to 1
0 | 1 => gives to 1
1 | 1 => gives to 1
0 | 0 => gives to 0

**Example:**

We want to perform Bitwise OR Operation of 6 and 8 (`6 | 8`), then

a = 6 = 0110 (In Binary)
b = 8 = 1000 (In Binary)

0110
| 1000
________
1110 = 14 (In decimal)

:::

:::section{.main}
## Bitwise Complement (`~`)
The Bitwise Not means the `negation` of each `bit` of the input value. It takes only one `integer`. It is also called Complement operator.
All samples of `0` become `1`, and all samples of `1` become `0`. In other words, `NOT` invert each input bit. This inverted cycle is called the 1’s complement of a bit series.

This makes the number negative as any `bit` sequence starting with `1` is negative, as here `N = ~N` always produce results `-(N+1)`. Because the system store data in the form of 2's complement which means it stores `~N` like this.

~N = -(~(~N)+1) =-(N+1). 

**Example:**

We want to perform a Bitwise Complement of `6 (~6)`, then
1. Representing the number in binary format
`a = 6 => 0110` (In Binary)

2. Now we have to find `~6`(means `1's` compliment of `6`)
`0000 0110 => 1111 1001` (flip each `1's` to `0` and vice versa)
So, ``~6 = 1111 1001``,
Here, MSB(Most Significant Bit) is 1(means negative value).
Then, in memory, it will be represented as 2's compliment
(To find 2's compliment, we first have to find 1's compliment and then add 1 to it.)

3. Finding `2's` compliment of ~6 i.e 1111 1001

                   1's compliment                Adding 1 to it
       1111 1001 ==================> 0000 0110 =================> 0000 0110
                                                                  +       1
                                                                  ---------
                                                                  0000 0111 
        So, 2's compliment of 1111 1001, is 0000 0111 

4. Converting back to decimal format.
0000 0111 => 7

In step2: we have seen that the number is negative, so the final answer would be -7

So, ~6 === -7 (result of bitwise complement)

:::

:::section{.main}
## Bitwise XOR (``^``)
The `bitwise XOR operation (^)` is a binary operator that takes two input states and compares each corresponding bit. If the bits are opposite, the solution has a `1` in that `bit` position, and if they are matched, a `0` is returned.

1 ^ 1 => gives 0.
0 ^ 0 => gives 0.
1 ^ 0 => gives 1.
0 ^ 1 => gives 1.

**Example:**

We want to perform Bitwise XOR Operation of 6 and 8 (6 ^ 8), then.

a = 6 = 0110 (In Binary)
b = 8 = 1000 (In Binary)

0110
^ 1000
________
1110 = 14 (In decimal)

:::

:::section{.tip}

* `XOR` is used to flip selected single bits in a `register` or replace bit patterns that show `Boolean` states.
* It is widely used in cryptography and in producing `parity bits` to check error and fault tolerance.
:::

:::section{.main}
## Bit Shift (`>>, <<,>>>`)
A "bit shift" refers to a fundamental bitwise operation used to manipulate binary data efficiently in computing. It involves moving the positions of binary digits within a number's representation either to the left or right, based on a specified number of spaces indicated by the second operand. This operation can be applied to integral data types including integers (such as int, long, short), bytes, and characters (char).

There are four types of shifts:

1. Signed Left shift operator (<<)
2. Signed Right shift operator(>>)
3. Unsigned Left shift operator (<<<)
4. Unsigned Right shift operator (>>>)

**a. `Signed Left shift operator`**: `<<` is the left shift operator and meets both logical and arithmetic shifts’ needs.

**Example:**

// left shift of 2
2 = 0010 (In Binary)

// perform 2 bit left shift
2 << 2: 0010 << 2 = 1000 (equivalent to 8)

**b. `Arithmetic/signed right shift`**: `>>` is the arithmetic (or signed) right shift operator.

**Example:**

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

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

**c. `Unsigned Left shift operator`**: `<<<` is the logical (or unsigned) left shift operator. It performs the same operation as the left shift operator, but its sign is not preserved.

**d. `Unsigned Right shift operator`**: `>>>` is the logical (or unsigned) right shift operator. It performs the same operation as the right shift operator, but its sign is not preserved in the operation.


**Example:**

// unsigned right shift of 8
8 = 0000 1000 (In Binary)
        
// Unsigned shift ``>>>`` will not keep the sign bit 
// (thus filling 0s) for positive numbers
        
8 >>> 2 = 0000 0010 ==> 2 (in decimal)

// unsigned right shift of ``-8``
// however, here numbers are not filled with zero as above
-8 = 1111 1000 (see calculation above)

-8 >>> 2 = 1111 1110 ==> 254 (in decimal)

:::

:::section{.main}
## Advantages of Bitwise Operators in Java

1. You will have situations where you would like to `set/clear/toggle` just one specific bit of a register without operating on the whole register. Using bitwise operators in Java, you can do a read and perform an `OR/AND/XOR` operation with the suitable mask to modify only the desired bit position.
2. Usually, bitwise operations are faster than doing multiply/divide.
3. Similarly, if you wish to use an array as a circular queue, it'd be faster(and more elegant) to handle wraparound checks with bit-wise operations (your array size should be a power of 2).
4. Also, if you want a program `error flag' to hold multiple error codes together for multiple scenarios, each bit can hold a separate value. You can `AND` it with each error code as a check. One such use case is `Unix error codes`.
5. Also, a `n-bit bitmap` can be a compact data structure. If you want to allocate a resource pool of size n, we can use n-bits to represent the current status.
6. In `Compression & Encryption`, both heavily depend on bitwise algorithms. For example, look at the deflate algorithm - everything is in bits, not bytes. For example:- `Huffman Coding` (for compression) and `Data Encryption` Standard (for encryption)

:::

:::section{.summary}
## Conclusion

- Bitwise operators in Java are faster than standard arithmetic operators, which operate on decimal numbers.
Logical and Bitwise operations are two different types of operations. The former operate on boolean data types, whereas the latter operate on bits.
- **AND** bitwise operator returns 1 if both bits are set.
- **OR** bitwise operator returns 1 if at least one of the operand bits is set.
- **XOR** bitwise operator returns 1 if the operand bits are opposite in value.

:::
:::section{.faqs}
## FAQs

**Q1. What are bitwise operators?**
**A:** Bitwise operators in java are operators used to manipulate individual bits of binary numbers.

**Q2. How many bitwise operators are there?**
**A:** There are six bitwise operators in most programming languages: AND (&), OR (|), XOR (^), NOT (~), left shift (<<), and right shift (>>).

**Q3. In which scenarios are bitwise operators commonly used?**
**A:** Bitwise operators are commonly used in low-level programming, such as device drivers, embedded systems, cryptography, and optimization tasks.

**Q4. Are bitwise operators platform-independent?**
**A:** Yes, Bitwise operators themselves are generally platform-independent.
:::