Java Logical Bitwise Operators and Priority Tutorial
Table of Contents
Study and learn Java MCQ Questions and Answers on Bitwise Operators and their priorities. Attend job interviews easily with these Multiple Choice Questions
Java language allows developers to work with individual bits of a number using Logical Bitwise Operators. Bitwise logical operators and Logical Bitwise Operators are one and the same. Simply use the term “Bitwise Operators” to refer to bitwise operators. Do not use the word Logical.
Bitwise Operators vs Logical Operators in Java
| Bitwise Operators | Logical Operators |
|---|---|
| Bitwise operators work with integer type data | Logical operators work with boolean type data.So use LOGICAL to refer to boolean logical operators. |
| If boolean operands are present, use Bitwise Operators. | If Relational operators are present, use Logical Operators. |
| Bitwise operations are used less in general. | Programmers use logical operators very often. |
| Bitwise operators are ~, &, |, ^, <<, >>, >>> and op=. | Logical operators are !, &, &&, |, ||, ^ and op=. |
Bitwise Operators in JAVA
The common operators used in both Bitwise Operation and Logical Operation are as follows.
- AND – &
- OR – |
- Exclusive OR or XOR – ^
- Compound AND – &=
- Compound OR – |=
- Compound XOR ^=
Bitwise Operators and Priority
Each integer type number contains so many bits of information. The purpose of bitwise operators is to manipulate individual bits of an integer type number.
Supported Five Integer Types for Bitwise Operation are as follows.
- byte (8 bits)
- char (16 bits) – unsigned
- short (16 bits)
- int (32 bits)
- long (64 bits)
We have shown 6 different groups of bitwise operators with priority. This priority or precedence is used to resolve a deadlock in solving equal priority operations in an arithmetic expression.
| Priority | Operator | Simple Name |
|---|---|---|
| 1 | TILDE ~ | Bitwise Unary NOT |
| 2 | >> | Shift Right |
| 2 | << | Shift Left |
| 2 | >>> | Shift Right Zero Fill |
| 3 | & Ampersand | Bitwise AND |
| 4 | ^ CARAT | Bitwise Exclusive OR |
| 5 | | PIPE | Bitwise OR |
| 6 | op= | Assignment Operatora op= ba = a op b |
| 6 | &= | Bitwise AND Assignmenta &=ba= a&b |
| 6 | |= | Bitwise OR Assignmenta |=ba= a|b |
| 6 | ^= | Bitwise Exclusive OR Assignmenta ^=ba= a^b |
| 6 | >>= | Bitwise Shift Right Assignmenta >>=ba= a>>b |
| 6 | >>>= | Bitwise Shift Right Fill Zero Assignmenta >>>=ba= a>>>b |
| 6 | <<= | Bitwise Shift Left Assignmenta <<=ba= a<<b |
Bitwise operators have less priority than arithmetic and relational operators. Only Bitwise Unary NOT or Bitwise Complementary Operator (~) has the highest priority than arithmetic and relational operators.
Example: Bitwise Operator Priority
class BitwisePriority
{
public static void main(String args[])
{
int a=5; 0101
int b=6; 0110
//12 1100 -
// 5 0101 -
int c = a&b+6;
System.out.println(c);
}
}
//OUTPUT
//a&(b+6)
//a&12
//5&12
//4
Note: We have used Binary Literals in this example. A binary literal starts with 0b. You can specify a number in binary format using this notation. Also, “op” refers to “Operand” in this tutorial.
1. Bitwise Unary NOT Operator (~ TILDE)
Bitwise Unary NOT operator (~) is also called Bitwise Complement Operator. It simply turns bit 0 to bit 1 and bit 1 to bit 0. We have used Type Casting to byte data type in most of the examples here.
Usage example:
class UnaryNOT
{
public static void main(String args[])
{
byte a = 0b00001010; //a=10
byte b = (byte)~a;
System.out.println(a + ", " + b);
}
}
//OUTPUT: 10, -11
| Operand | Result |
|---|---|
| 0 | 1 |
| 1 | 0 |
2. Bitwise AND Operator (&)
Bitwise AND operator gives an output of 1 only if both the input bits are 1s. Even if one input bit is 0, the output is 0. Here operand is synonymous to input bit.
Usage example:
class BitwiseAND
{
public static void main(String args[])
{
byte a = 0b00001010; //a=10
byte b = 0b00111001; //b=57
//00001000 = 8
byte c = a & b;
System.out.println(a + ", " + b + "= " + c);
}
}
//OUTPUT: 10, 57 = 8
| Op1 | Op2 | Result |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
3. Bitwise OR Operator (|)
Bitwise OR Operator (|) gives an output of 1 at least if one input bit is 1. Only if both the input bits are 0s, the output is 0.
Usage example:
class BitwiseOR
{
public static void main(String args[])
{
byte a = 0b00001010; //a=10
byte b = 0b00111001; //b=57
//00111011 = 59
byte c = a | b;
System.out.println(a + ", " + b + "= " + c);
}
}
//OUTPUT: 10, 57 = 59
| Op1 | Op2 | Result |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
4. Bitwise Exclusive OR Operator (^)
Bitwise XOR Operator (|) or Bitwise Exclusive OR operator gives an output of 1 if both the input bits are different i.e 1,0 or 0, 1. If both the input bits are same i.e 0,0 or 1,1, the output is 0.
Usage example:
class BitwiseXOR
{
public static void main(String args[])
{
byte a = 0b00001010; //a=10
byte b = 0b00111001; //b=57
//00110011 = 51
byte c = a ^ b;
System.out.println(a + ", " + b + "= " + c);
}
}
//OUTPUT: 10, 57 = 51
| Op1 | Op2 | Result |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
5. Bitwise Shift Left Operator or Left Shift Operator (<<)
Bitwise Shift Left or Right Shift operator shifts the individual bits from Right to Left. So gaps are formed on the right side. These gaps are filled with 0s. Left most bits are discarded.
Note: If discarded bits on the left side are zeroes, Left Shift operation is equivalent to multiplying the number by 2.
Usage example:
class BitwiseLeftShift
{
public static void main(String args[])
{
byte a = 0b00001010; //a=10
//00010100 //20
byte b = (byte)(a << 1);
System.out.println(a + ", " + b);
byte c = 0b01010111; //87
//0101-01110000
//Left 4 bits discarded
byte d = (byte)(c << 4);
System.out.println(c + ", " + d);
}
}
//OUTPUT:
//10, 20
//87, 112
6. Bitwise Shift Right or Right Shift Operator Operator (>>)
Right Shift Operator shifts the individual bits of a number towards Right Side from the Left Side. Usually Left Most bits are filled with Zeroes in the process of filling gaps created because shifting bits to the right side. Shift Right operator does Sign Extension by putting the Left Most Bits to 1s if they are already 1s. So, negative numbers are still negative numbers after the Right Shift operation.
Note: Right Shift operation is equivalent to dividing the number by 2.
Usage example:
class BitwiseRightShift
{
public static void main(String args[])
{
byte a = 0b00010100; //a=20
//00001010 //10
byte b = (byte)(a >> 1); //=20/2
System.out.println(a + ", " + b);
byte c = 0b01010111; //87
//00000101-0111 //5
//Right 4 bits discarded
byte d = (byte)(c >> 4); //=87/(2*2*2*2)
System.out.println(c + ", " + d);
byte e = (byte)0b11111000; //-8
//11111100 //-4
//Right 1 bit discarded
byte f = (byte)(e >> 1);
System.out.println(e + ", " + f);
}
}
//OUTPUT:
//20, 10
//87, 5
//-8, -4
7. Bitwise Shift Right Zero Fill Operator (or) Unsigned Right Shift Operator (>>>)
Unsigned Shift Right or Shift Right Fill Zero operator shifts the individual bits of a number from Left to Right. It fills Zeroes on the left side in the gaps created by shifting the digits to the right. This operator does not maintain Sign Extension. So, a negative number may become a positive number after the Right Shift Fill Zero operation.
Note: Right Shift Fill Zero operation is equivalent to dividing the number by 2.
Usage example:
class BitwiseRightShiftUnsigned
{
public static void main(String args[])
{
byte a = 0b00010100; //a=20
//00001010 //10
byte b = (byte)(a >>> 1); //=20/2
System.out.println(a + ", " + b);
byte c = 0b01010111; //87
//00000101-0111 //5
//Right 4 bits discarded
byte d = (byte)(c >>> 4); //=87/(2*2*2*2)
System.out.println(c + ", " + d);
int e = -1;//(byte)0b11111111;
//11111111 11111111 11111111 11111111 //-1
//00000000 00000000 00000000 00001111 //15
int f = (int)(e >>> 28);
System.out.println(e + ", " + f);
}
}
//OUTPUT:
//20, 10
//87, 5
//-1, -15
This is all about Bitwise Operators in Java. You should practice these examples on your PC for better understanding.
[WpProQuiz 70]
Bitwise Operators in Java MCQ
1) What is the output of the Java program?
byte b = 0b0000101; System.out.print(b + ","); b &= 0b00001111; System.out.print(b);
A) 5, 0
B) 5,5
C) 5,15
D) None
Answer [=] B
Explanation:
0101 & 1111 = 0101. &= is a Bitwise AND Shorthand Assignement operator.
2) What is the output of the Java program?
byte b = 0b00000101; System.out.print(b + ","); b |= 0b00001111; System.out.print(b); A) 5,0 B) 5,5 C) 5,15 D) Compiler error
Answer [=] C
Explanation:
|= is a Bitwise OR Shorthand Assignment operator. a |= b ---> a = a|b;
3) What is the output of the Java Program?
byte b = 0b00000101; System.out.print(b + ","); b ^= 0b00001111; System.out.print(b);
A) 5,0
B) 5,5
C) 5,10
D) 5,15
Answer [=] C
Explanation:
Bitwise exclusive OR produces 1 for different Inputs and 0 for the same Inputs. 0101 ^1111 ------ 1010
4) What is the output of the Java program?
byte b = 0b00000101; System.out.print(b + ","); b = (byte)~b; System.out.print(b);
A) 5, 10
B) 5, -10
C) 5. -6
D) Compiler error
Answer [=] C
Explanation:
Bitwise NOT(~) operator turns 1s to 0s and 0s to 1s. If the leftmost bit is 1, it is a negative number. So take 1's complement and add 1 to it. ~0000 0101 = 1111 1010 ----------- ~ 111 1010 = 000 0101 ----------- 000 0101 000 0001 + ----------- - 000 0110
5) What is the output of the Java program with Left Shift Operator (<<)?
byte b = 0b00000101; System.out.print(b + ","); b = (byte)(b << 1); System.out.print(b);
A) 5,2
B) 5,5
C) 5,10
D) Compiler error
Answer [=] C
Explanation:
Left Shift 1 bit. Before: 0000 0101 After: left 0 removed <-- 0 [000 0 101 0] <--- 0 added at right =0000 1010
6) What is the output of Java program with Right Shift Operator (>>)?
byte b = 0b00000101; System.out.print(b + ","); b = (byte)(b >> 1); System.out.print(b);
A) 5,-6
B) 5,10
C) 5, 2
D) Compiler error
Answer [=] C
Explanation:
Right Shift Operator shifts bits rightside. Fills 0s on the left side. Before: 0000 0101 After [0 0000 010]1 = 0000 0010
7) What is the output of the Java program with Right Shift (Without Fill Zeroes)?
byte num = (byte)0b1111_1000; System.out.print(num + ","); num = (byte)(num >> 1); System.out.print(num);
A) -8, -16
B) -4, -8
C) -8, -4
D) Compiler error
Answer [=] C
Explanation:
1111_1000 == ~111 1000 + 1 = 000 0111 + 1 = 000 1000 = -8 -8 >> 1 = 1111_1100 = ~ 111 1100 + 1 = 000 0011 + 1 = 000 0100 = -4
8) What is the output of a Java Program with Shift Right Fill Zeroes (>>>) operator?
byte num = (byte)0b1111_1000; System.out.print(num + ","); num = (byte)(num >>> 1); System.out.print(num);
A) -8, 8
B) -8, 4
C) -8, -4
D) Compiler error
Answer [=] C
Explanation:
In this case, >> and >>> produce the same output. A negative number is a negative number only.
9) What is the output of Java Program with Shift Right Fill Zeroes operator?
byte num = (byte)0b000_1000; System.out.print(num + ","); num = (byte)(num >>> 1); System.out.print(num);
A) -8, 4
B) 8, 4
C) 8, -4
D) -8, -4
Answer [=] B
10) What is the output of the Java program?
byte num = (byte)0b000_1000;
if(num >> 1 > 6)
{
System.out.print(num);
}
else
{
System.out.println(num>>1);
}
A) 8
B) 6
C) 4
D) Compiler error
Answer [=] C
Explanation:
(num>>1)>6 4 > 6 = false
11) What is the output of the Java Program?
byte num = (byte)0b000_1000;
if(num >> 1 > 6 || true)
{
System.out.print(num);
}
else
{
System.out.println(num>>1);
}
A) 8
B) 6
C) 4
D) 2
Answer [=] A
Explanation:
Logical OR (||) is executed at last. (4>6) || true = false||true = true
12) What is the output of the Java program?
byte num = (byte)0b000_1000;
if(num >> 1 > 6 || true | 2>3)
{
System.out.print(num+1);
}
else
{
System.out.println(num>>2);
}
A) 8
B) 6
C) 9
D) Compiler error
Answer [=] C
Explanation:
Each logic block is evaluated separately as it has less priority.