# Bitwise operators in Java

Bitwise operators are used to perform manipulation of individual bits of a number. They can be used with any of the integral types (char, short, int, etc). They are used when performing update and query operations of Binary indexed tree.

**Bitwise OR (|) –**

This operator is binary operator, denoted by ‘|’. It returns bit by bit OR of input values, i.e, if either of the bits is 1, it gives 1, else it gives 0.

For example,a = 5 = 0101 (In Binary) b = 7 = 0111 (In Binary) Bitwise OR Operation of 5 and 7 0101 | 0111 ________ 0111 = 7 (In decimal)

**Bitwise AND (&) –**

This operator is binary operator, denoted by ‘&’. It returns bit by bit AND of input values, i.e, if both bits are 1, it gives 1, else it gives 0.

For example,a = 5 = 0101 (In Binary) b = 7 = 0111 (In Binary) Bitwise AND Operation of 5 and 7 0101 & 0111 ________ 0101 = 5 (In decimal)

**Bitwise XOR (^) –**

This operator is binary operator, denoted by ‘^’. It returns bit by bit XOR of input values, i.e, if corresponding bits are different, it gives 1, else it gives 0.

For example,a = 5 = 0101 (In Binary) b = 7 = 0111 (In Binary) Bitwise XOR Operation of 5 and 7 0101 ^ 0111 ________ 0010 = 2 (In decimal)

**Bitwise Complement (~) –**

This operator is unary operator, denoted by ‘~’. It returns the one’s compliment representation of the input value, i.e, with all bits inversed, means it makes every 0 to 1, and every 1 to 0.

For example,

a = 5 = 0101 (In Binary) Bitwise Compliment Operation of 5 ~ 0101 ________ 1010 = 10 (In decimal)

**Note –**Compiler will give 2’s complement of that number, i.e., 2’s compliment of 10 will be -6.

`// Java program to illustrate ` `// bitwise operators ` `public` `class` `operators { ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `//Initial values ` ` ` `int` `a = ` `5` `; ` ` ` `int` `b = ` `7` `; ` ` ` ` ` `// bitwise and ` ` ` `// 0101 & 0111=0101 = 5 ` ` ` `System.out.println(` `"a&b = "` `+ (a & b)); ` ` ` ` ` `// bitwise or ` ` ` `// 0101 | 0111=0111 = 7 ` ` ` `System.out.println(` `"a|b = "` `+ (a | b)); ` ` ` ` ` `// bitwise xor ` ` ` `// 0101 ^ 0111=0010 = 2 ` ` ` `System.out.println(` `"a^b = "` `+ (a ^ b)); ` ` ` ` ` `// bitwise and ` ` ` `// ~0101=1010 ` ` ` `// will give 2's complement of 1010 = -6 ` ` ` `System.out.println(` `"~a = "` `+ ~a); ` ` ` ` ` `// can also be combined with ` ` ` `// assignment operator to provide shorthand ` ` ` `// assignment ` ` ` `// a=a&b ` ` ` `a &= b; ` ` ` `System.out.println(` `"a= "` `+ a); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

**Output :**

a&b = 5 a|b = 7 a^b = 2 ~a = -6 a= 5

**Shift Operators:** These operators are used to shift the bits of a number left or right thereby multiplying or dividing the number by two respectively. They can be used when we have to multiply or divide a number by two. General format:

numbershift_opnumber_of_places_to_shift;

**Signed Right shift operator (>>) –**

Shifts the bits of the number to the right and fills 0 on voids left as a result. The leftmost bit depends on the sign of initial number. Similar effect as of dividing the number with some power of two.

For example,Example 1: a = 10 a>>1 = 5 Example 2: a = -10 a>>1 = -5 We preserve the sign bit.

**Unsigned Right shift operator (>>>) –**

Shifts the bits of the number to the right and fills 0 on voids left as a result. The leftmost bit is set to 0. (>>>) is unsigned-shift; it’ll insert 0. (>>) is signed, and will extend the sign bit.

For example,Example 1: a = 10 a>>>1 = 5 Example 2: a = -10 a>>>1 = 2147483643 DOES NOT preserve the sign bit.

**Left shift operator (<<) –**

Shifts the bits of the number to the left and fills 0 on voids left as a result. Similar effect as of multiplying the number with some power of two.

For example,a = 5 = 0000 0101 b = -10 = 1111 0110 a << 1 = 0000 1010 = 10 a << 2 = 0001 0100 = 20 b << 1 = 0000 1010 = -20 b << 2 = 0001 0100 = -40

**Unsigned Left shift operator (<<<) –**

Unlike unsigned Right Shift, there is no “<<<" operator in Java, because the logical (<<) and arithmetic left-shift (<<<) operations are identical.

`// Java program to illustrate ` `// shift operators ` `public` `class` `operators { ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` ` ` `int` `a = ` `5` `; ` ` ` `int` `b = -` `10` `; ` ` ` ` ` `// left shift operator ` ` ` `// 0000 0101<<2 =0001 0100(20) ` ` ` `// similar to 5*(2^2) ` ` ` `System.out.println(` `"a<<2 = "` `+ (a << ` `2` `)); ` ` ` ` ` `// right shift operator ` ` ` `// 0000 0101 >> 2 =0000 0001(1) ` ` ` `// similar to 5/(2^2) ` ` ` `System.out.println(` `"b>>2 = "` `+ (b >> ` `2` `)); ` ` ` ` ` `// unsigned right shift operator ` ` ` `System.out.println(` `"b>>>2 = "` `+ (b >>> ` `2` `)); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

**Output :**

a<<2 = 20 b>>2 = -3 b>>>2 = 1073741821

Refer for – other Operators in Java

## Recommended Posts:

- Bitwise right shift operators in Java
- Case conversion (Lower to Upper and Vice Versa) of a string using BitWise operators in C/C++
- Operators in Java
- Java | Operators | Question 9
- Java | Operators | Question 7
- Java | Operators | Question 6
- Java | Operators | Question 5
- Java | Operators | Question 8
- Java | Operators | Question 1
- Basic Operators in Java
- Java | Operators | Question 2
- Java | Operators | Question 4
- Java | Operators | Question 3
- Compound assignment operators in Java
- Interesting facts about Increment and Decrement operators in Java

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.