In deze tutorial leren we aan de hand van voorbeelden over de bitwise-operator en verschillende soorten shift-operators in Java.
In Java voeren bitsgewijze operators bewerkingen uit op gegevens van gehele getallen op het individuele bitniveau. Hier, de integer data omvat byte, short, int, en de longsoorten gegevens.
Er zijn zeven operators om bewerkingen op bitniveau in Java uit te voeren.
| Operator | Omschrijving |
|---|---|
| | Bitsgewijs OF |
& | Bitwise EN |
^ | Bitsgewijze XOR |
~ | Bitsgewijze aanvulling |
<< | Linker shift |
>> | Gesigneerd Right Shift |
>>> | Niet-ondertekende rechterverschuiving |
1. Java Bitwise OF Operator
De bitsgewijze OR- |operator retourneert 1 als ten minste één van de operanden 1 is. Anders retourneert het 0.
De volgende waarheidstabel toont de werking van de bitsgewijze OR-operator. Laat a en b twee operanden zijn die alleen binaire waarden kunnen aannemen, dwz 1 of 0.
| een | b | een | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
De bovenstaande tabel staat bekend als de "Truth Table" voor de bitsgewijze OR-operator.
Laten we eens kijken naar de bitsgewijze OR-bewerking van twee gehele getallen 12 en 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Voorbeeld 1: Bitwise OR
class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise OR between 12 and 25 result = number1 | number2; System.out.println(result); // prints 29 ) )
2. Java Bitwise AND Operator
De bitsgewijze AND- &operator retourneert 1 als en alleen als beide operanden 1 zijn. Anders retourneert het 0.
De volgende tabel toont de werking van de bitsgewijze AND-operator. Laat a en b twee operanden zijn die alleen binaire waarden kunnen aannemen, dwz 1 en 0.
| een | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Laten we eens kijken naar de bitsgewijze EN-bewerking van twee gehele getallen 12 en 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Voorbeeld 2: Bitwise AND
class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise AND between 12 and 25 result = number1 & number2; System.out.println(result); // prints 8 ) )
3. Java Bitwise XOR-operator
De bitsgewijze XOR- ^operator retourneert 1 als en alleen als een van de operanden 1 is. Echter, als beide operanden 0 zijn of als beide 1 zijn, dan is het resultaat 0.
De volgende waarheidstabel toont de werking van de bitsgewijze XOR-operator. Laat a en b twee operanden zijn die alleen binaire waarden kunnen aannemen, dwz 1 of 0.
| een | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Laten we eens kijken naar de bitsgewijze XOR-bewerking van twee gehele getallen 12 en 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Voorbeeld 4: Bitwise XOR
class Main ( public static void main(String() args) ( int number1 = 12, number2 = 25, result; // bitwise XOR between 12 and 25 result = number1 number2; System.out.println(result); // prints 21 ) )
4. Java Bitwise Complement Operator
De bitsgewijze complementoperator is een unaire operator (werkt met slechts één operand). Het wordt aangeduid met ~.
Het verandert de binaire cijfers 1 in 0 en 0 in 1 .
Java Bitwise Complement Operator
It is important to note that the bitwise complement of any integer N is equal to - (N + 1). For example,
Consider an integer 35. As per the rule, the bitwise complement of 35 should be -(35 + 1) = -36. Now let's see if we get the correct answer or not.
35 = 00100011 (In Binary) // using bitwise complement operator ~ 00100011 __________ 11011100
In the above example, we get that the bitwise complement of 00100011 (35) is 11011100. Here, if we convert the result into decimal we get 220.
However, it is important to note that we cannot directly convert the result into decimal and get the desired output. This is because the binary result 11011100 is also equivalent to -36.
To understand this we first need to calculate the binary output of -36.
2's Complement
In binary arithmetic, we can calculate the binary negative of an integer using 2's complement.
1's complement changes 0 to 1 and 1 to 0. And, if we add 1 to the result of the 1's complement, we get the 2's complement of the original number. For example,
// compute the 2's complement of 36 36 = 00100100 (In Binary) 1's complement = 11011011 2's complement: 11011011 + 1 _________ 11011100
Hier kunnen we zien dat het 2-complement van 36 (dwz -36 ) 11011100 is . Deze waarde is gelijk aan het bitsgewijze complement van 35 .
Daarom kunnen we zeggen dat de bitsgewijze complement van 35 is - (35 + 1) = -36 .
Voorbeeld 3: bitsgewijze aanvulling
class Main ( public static void main(String() args) ( int number = 35, result; // bitwise complement of 35 result = ~number; System.out.println(result); // prints -36 ) )
Java Shift-operators
Er zijn drie soorten ploegendienstoperatoren in Java:
- Gesigneerd Left Shift (<<)
- Gesigneerd Right Shift (>>)
- Unsigned Right Shift (>>>)
5. Java Linker Shift-operator
De linker shift-operator verschuift alle bits naar links met een bepaald aantal gespecificeerde bits. Het wordt aangeduid met <<.
Java 1 bit Linker Shift-operator
As we can see from the image above, we have a 4-digit number. When we perform a 1 bit left shift operation on it, each individual bit is shifted to the left by 1 bit.
As a result, the left-most bit (most-significant) is discarded and the right-most position(least-significant) remains vacant. This vacancy is filled with 0s.
Example 5: Left Shift Operators
class Main ( public static void main(String() args) ( int number = 2; // 2 bit left shift operation int result = number << 2; System.out.println(result); // prints 8 ) )
5. Java Signed Right Shift Operator
The signed right shift operator shifts all bits towards the right by a certain number of specified bits. It is denoted by >>.
When we shift any number to the right, the least significant bits (rightmost) are discarded and the most significant position (leftmost) is filled with the sign bit. For example,
// right shift of 8 8 = 1000 (In Binary) // perform 2 bit right shift 8>> 2: 1000>> 2 = 0010 (equivalent to 2)
Hier voeren we de verschuiving naar rechts van 8 uit (dwz teken is positief). Daarom is er geen tekenbit. Dus de meest linkse bits zijn gevuld met 0 (staat voor een positief teken).
// right shift of -8 8 = 1000 (In Binary) 1's complement = 0111 2's complement: 0111 + 1 _______ 1000 Signed bit = 1 // perform 2 bit right shift 8>> 2: 1000>> 2 = 1110 (equivalent to -2)
Hier hebben we bit 1 met teken gebruikt om de meest linkse bits te vullen.
Voorbeeld 6: ondertekende rechtshiftoperator
class Main ( public static void main(String() args) ( int number1 = 8; int number2 = -8; // 2 bit signed right shift System.out.println(number1>> 2); // prints 2 System.out.println(number2>> 2); // prints -2 ) )
7. Java niet-ondertekende rechterdienstoperator
Java biedt ook een niet-ondertekende rechterverschuiving. Het wordt aangeduid met >>>.
Hier wordt de vacante meest linkse positie gevuld met 0 in plaats van het tekenbit. Bijvoorbeeld,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Voorbeeld 7: niet-ondertekende rechterverschuiving
class Main ( public static void main(String() args) ( int number1 = 8; int number2 = -8; // 2 bit signed right shift System.out.println(number1>>> 2); // prints 2 System.out.println(number2>>> 2); // prints 1073741822 ) )
Zoals we kunnen zien, retourneert de operator voor ondertekende en niet-ondertekende rechterverschuiving verschillende resultaten voor negatieve bits. Ga voor meer informatie naar het verschil tussen >> en >>>.
