Open In App

Bitwise Operators in Java

Last Updated : 07 May, 2024
Improve
Improve
Like Article
Like
Save
Share
Report


Operators constitute the basic building block of any programming language. Java too provides many types of operators which can be used according to the need to perform various calculations and functions, be it logical, arithmetic, relational, etc. They are classified based on the functionality they provide. Here are a few types: 

  1. Arithmetic Operators
  2. Unary Operators
  3. Assignment Operator
  4. Relational Operators
  5. Logical Operators
  6. Ternary Operator
  7. Bitwise Operators
  8. Shift Operators

This article explains all that one needs to know regarding Bitwise Operators. 

Bitwise Operators

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

Now let’s look at each one of the bitwise operators in Java: 

1. 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)

2. 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)

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 returns the one’s complement representation of the input value, i.e., with all bits inverted, which means it makes every 0 to 1, and every 1 to 0. 

Example:

a = 5 = 0101 (In Binary)

Bitwise Complement Operation of 5

~ 0101
________
1010 = 10 (In decimal)

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

Java
// 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 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

Auxiliary space:O(1) 

Time complexity:O(1) 

Java
// Demonstrating the bitwise logical operators


class GFG {
    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 4 types. These are:

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

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

program to implement all Bitwise operators in java for user input

Java
import java.util.Scanner;

public class BitwiseOperators {
    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:

Bitwise AND
Bitwise OR
Bitwise XOR
Bitwise NOT
Bitwise Left Shift
Bitwise Right Shift
Bitwise Zero Fill Right Shift

Advantages 

The advantages of using Bitwise Operators in Java are:

  1. Speed: Bitwise operations are much faster than arithmetic operations as they operate directly on binary representations of numbers.
  2. Space Optimization: Bitwise operations can be used to store multiple values in a single variable, which can be useful when working with limited memory.
  3. Bit Manipulation: Bitwise operators allow for precise control over individual bits of a number, which can be useful in various applications such as cryptography, error detection, and compression.
  4. Code Simplification: Bitwise operations can simplify the code by reducing the number of conditional statements and loops required to perform certain tasks.

In summary, Bitwise Operators are an important tool for optimizing performance, improving code readability, and reducing code complexity in Java applications.



Previous Article
Next Article

Similar Reads

Bitwise Right Shift Operators in Java
In C/C++ there is only one right shift operator '&gt;&gt;' which should be used only for positive integers or unsigned integers. Use of the right shift operator for negative numbers is not recommended in C/C++, and when used for negative numbers, the output is compiler dependent. Unlike C++, Java supports following two right shift operators. Here w
2 min read
Complete Reference for Bitwise Operators in Programming/Coding
There exists no programming language that doesn't use Bit Manipulations. Bit manipulation is all about these bitwise operations. They improve the efficiency of programs by being primitive, fast actions. There are different bitwise operations used in bit manipulation. These Bitwise Operators operate on the individual bits of the bit patterns. Bit op
13 min read
Java | Operators | Question 1
Predict the output of following Java Program class Test { public static void main(String args[]) { int x = -4; System.out.println(x&gt;&gt;1); int y = 4; System.out.println(y&gt;&gt;1); } } (A) Compiler Error: Operator &gt;&gt; cannot be applied to negative numbers (B) -2 2 (C) 2 2 (D) 0 2 Answer: (B) Explanation: See https://www.geeksforgeeks.org/
1 min read
Java | Operators | Question 2
Predict the output of following Java program. Assume that int is stored using 32 bits. class Test { public static void main(String args[]) { int x = -1; System.out.println(x&gt;&gt;&gt;29); System.out.println(x&gt;&gt;&gt;30); System.out.println(x&gt;&gt;&gt;31); } } (A) 7 3 1 (B) 15 7 3 (C) 0 0 0 (D) 1 1 1 Answer: (A) Explanation: Please see https
1 min read
Java | Operators | Question 3
class Test { public static void main(String args[]) { System.out.println(10 + 20 + &quot;GeeksQuiz&quot;); System.out.println(&quot;GeeksQuiz&quot; + 10 + 20); } } (A) 30GeeksQuiz GeeksQuiz30 (B) 1020GeeksQuiz GeeksQuiz1020 (C) 30GeeksQuiz GeeksQuiz1020 (D) 1020GeeksQuiz GeeksQuiz30 Answer: (C) Explanation: In the given expressions 10 + 20 + "Geeks
1 min read
Java | Operators | Question 4
class Test { public static void main(String args[]) { System.out.println(10*20 + &quot;GeeksQuiz&quot;); System.out.println(&quot;GeeksQuiz&quot; + 10*20); } } (A) 10*20GeeksQuiz GeeksQuiz10*20 (B) 200GeeksQuiz GeeksQuiz200 (C) 200GeeksQuiz GeeksQuiz10*20 (D) 1020GeeksQuiz GeeksQuiz220 Answer: (B) Explanation: Precedence of * is more than +.Quiz of
1 min read
Java | Operators | Question 5
Which of the following is not an operator in Java? (A) instanceof (B) sizeof (C) new (D) &gt;&gt;&gt;= Answer: (B) Explanation: There is no sizeof operator in Java. We generally don't need size of objects.Quiz of this Question
1 min read
Java | Operators | Question 6
class Base {} class Derived extends Base { public static void main(String args[]){ Base a = new Derived(); System.out.println(a instanceof Derived); } } (A) true (B) false Answer: (A) Explanation: The instanceof operator works even when the reference is of base class type.Quiz of this Question
1 min read
Java | Operators | Question 7
class Test { public static void main(String args[]) { String s1 = &quot;geeksquiz&quot;; String s2 = &quot;geeksquiz&quot;; System.out.println(&quot;s1 == s2 is:&quot; + s1 == s2); } } (A) true (B) false (C) compiler error (D) throws an exception Answer: (B) Explanation: The output is “false” because in java + operator precedence is more than == op
1 min read
Java | Operators | Question 8
class demo { int a, b, c; demo(int a, int b, int c) { this.a = a; this.b = b; } demo() { a = b = c = 0; } demo operator+(const demo &amp;obj) { demo object; object.a = this.a + obj.a; object.b = this.b + obj.b; object.c = this.c + obj.c; return object; } } class Test { public static void main(String[] args) { demo obj1 = new demo(1, 2, 3); demo obj
1 min read