Bitwise Operators in Java (original) (raw)

Bitwise operators in Java operate directly on the binary representation of integer values, performing operations bit by bit instead of on whole numbers. This makes them efficient for low-level processing and performance-critical tasks.

• Work only with integral types like byte, short, int, long, and char
• Used in system-level programming, optimization, and competitive coding
• Help in fast bit manipulation such as masking, shifting, and toggling bits

Let us now look at each bitwise operator and understand its working with examples.

1. Bitwise AND (&)

This operator is a 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 shows 0.

**Example:

a = 5 = 0101 (In Binary)
b = 7 = 0111 (In Binary)

Bitwise AND Operation of 5 and 7
0101
& 0111
________
0101 = 5 (In decimal)

2. Bitwise OR (|)

This operator is a 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 shows 0.

**Example:

a = 5 = 0101 (In Binary)
b = 7 = 0111 (In Binary)

Bitwise OR Operation of 5 and 7
0101
| 0111
________
0111 = 7 (In decimal)

3. Bitwise XOR (^)

This operator is a 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 shows 0.

**Example:

a = 5 = 0101 (In Binary)
b = 7 = 0111 (In Binary)

Bitwise XOR Operation of 5 and 7
0101
^ 0111
________
0010 = 2 (In decimal)

4. Bitwise Complement (~)

This operator is a unary operator, denoted by '~'. It inverts all the bits of the given number (0 becomes 1 and 1 becomes 0).

**Important: In Java, int is a 32-bit signed integer.

**Example:

a = 5

32-bit binary representation of 5:
00000000 00000000 00000000 00000101

After applying ~a (bitwise complement):
11111111 11111111 11111111 11111010

In decimal, this value is -6.
This is because in Java:

~N = -(N + 1)
So
~5 = -(5 + 1) = -6

**Explanation: The bitwise complement operator ~ in Java inverts all 32 bits of an integer.
For any integer N, the result of ~N is equal to:

~N = -(N + 1)

Therefore, ~5 = -(5 + 1) = -6.
**Illustration: Here is a Java program demonstrating all bitwise operators.

Java `

public class Geeks { 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 not
    // ~00000000 00000000 00000000 00000101=11111111 11111111 11111111 11111010
    // will give 2's complement (32 bit) of 5 = -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);
}

}

`

Output

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

**Example: Display Bitwise Operations in Binary Format

Java `

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

    String binary[]={
      "0000","0001","0010","0011","0100","0101",
      "0110","0111","1000","1001","1010",
      "1011","1100","1101","1110","1111"
    };
  
  // initializing the values of a and b 
  int a=3; // 0+2+1 or 0011 in binary
  int b=6; // 4+2+0 or 0110 in binary
  
  // bitwise or
  int c= a | b;
  
  // bitwise and
  int d= a & b;
  
  // bitwise xor
  int e= a ^ b;
  
  // bitwise not
  int f= (~a & b)|(a &~b);
  int g= ~a & 0x0f;
  
  
  System.out.println(" a= "+binary[a]);
  System.out.println(" b= "+binary[b]);
  System.out.println(" a|b= "+binary[c]);
  System.out.println(" a&b= "+binary[d]);
  System.out.println(" a^b= "+binary[e]);
  System.out.println("~a & b|a&~b= "+binary[f]);
  System.out.println("~a= "+binary[g]);
}

}

`

Output

a= 0011 b= 0110 a|b= 0111 a&b= 0010 a^b= 0101 a & b|a&b= 0101 ~a= 1100

**Bit-Shift Operators (Shift Operators)

Shift 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.

**Syntax:

number **shift_op number_of_places_to_shift;

**Types of Shift Operators

Shift Operators are further divided into 3 types. These are:

• **Signed Right shift operator (>>) : Shifts bits to the right and preserves the sign bit (MSB), filling left side with the sign bit.
• **Unsigned Right shift operator (>>>) : Shifts bits to the right and fills the left side with 0, ignoring the sign bit.
• **Left shift operator (<<) : Shifts bits to the left and fills the right side with 0, effectively multiplying the number by powers of 2.

**Note: For more detail about the Shift Operators in Java, refer Shift Operator in Java.

**Example: Program to Implement all Bitwise Operators in Java for User Input

Java `

import java.util.Scanner;

public class Geeks { public static void main(String[] args) { Scanner input = new Scanner(System.in);

    System.out.print("Enter first number: ");
    int num1 = input.nextInt();

    System.out.print("Enter second number: ");
    int num2 = input.nextInt();

    System.out.println("Bitwise AND: " + (num1 & num2));
    System.out.println("Bitwise OR: " + (num1 | num2));
    System.out.println("Bitwise XOR: " + (num1 ^ num2));
    System.out.println("Bitwise NOT: " + (~num1));
    System.out.println("Bitwise Left Shift: " + (num1 << 2));
    System.out.println("Bitwise Right Shift: " + (num1 >> 2));
    System.out.println("Bitwise Unsigned Right Shift: " + (num1 >>> 2));

    input.close();
}

}

`

**Input:

Enter first number: 4
Enter second number: 8

**Output:

Bitwise AND: 0
Bitwise OR: 12
Bitwise XOR: 12
Bitwise NOT: -5
Bitwise Left Shift: 16
Bitwise Right Shift: 1
Bitwise Unsigned Right Shift: 1

**Explanation: This program prompts the user to enter two numbers, num1 and num2. It then performs the following bitwise operations using the &, |, ^, ~, <<, >>, and >>> operators:

Comparision table