I den här handledningen lär vi oss om bitvis operatör och olika typer av skiftoperatörer i Java med hjälp av exempel.
I Java utför bitvisa operatörer operationer på heltaldata på den enskilda bitnivån. Här innehåller heltal uppgifter byte, short, intoch longtyper av data.
Det finns 7 operatörer för att utföra bitnivååtgärder i Java.
| Operatör | Beskrivning |
|---|---|
| | Bitvis ELLER |
& | Bitvis OCH |
^ | Bitvis XOR |
~ | Bitvis komplement |
<< | Vänster Shift |
>> | Signerad högerförskjutning |
>>> | Osignerad högerförskjutning |
1. Java bitvis ELLER operatör
Den bitvisa ELLER- |operatören returnerar 1 om minst en av operanderna är 1. Annars returnerar den 0.
Följande sanningstabell visar hur bitvis OR-operatören fungerar. Låt a och b vara två operander som bara kan ta binära värden, dvs. 1 eller 0.
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Ovanstående tabell är känd som "Sanningstabellen" för bitvis ELLER-operatör.
Låt oss titta på bitvis ELLER-operation av två heltal 12 och 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Exempel 1: Bitvis ELLER
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 bitvis OCH operatör
Bitvis OCH- &operatör returnerar 1 om och bara om båda operanderna är 1. Annars returnerar den 0.
Följande tabell visar hur bitvis AND-operatören fungerar. Låt a och b vara två operander som bara kan ta binära värden, dvs. 1 och 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Låt oss titta på bitvis OCH-operation av två heltal 12 och 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Exempel 2: Bitvis OCH
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-operatör
Den bitvisa XOR- ^operatören returnerar 1 om och endast om en av operanderna är 1. Om båda operanderna är 0 eller om båda är 1 är resultatet 0.
Följande sanningstabell visar hur den bitvisa XOR-operatören fungerar. Låt a och b vara två operander som bara kan ta binära värden, dvs. 1 eller 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Låt oss titta på den bitvisa XOR-operationen av två heltal 12 och 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Exempel 4: Bitvis 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 komplementoperatör
Bitvis komplementoperatören är en enhetlig operatör (fungerar med endast en operand). Det betecknas med ~.
Det ändrar binära siffror 1 till 0 och 0 till 1 .
Java Bitwise komplementoperatör
Det är viktigt att notera att det bitvisa komplementet för alla heltal N är lika med - (N + 1) . Till exempel,
Betrakta ett heltal 35 . Enligt regeln bör det bitvisa komplementet på 35 vara - (35 + 1) = -36 . Låt oss nu se om vi får rätt svar eller inte.
35 = 00100011 (In Binary) // using bitwise complement operator ~ 00100011 __________ 11011100
I exemplet ovan får vi att bitvis komplement av 00100011 ( 35 ) är 11011100 . Här, om vi konverterar resultatet till decimal får vi 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
Här kan vi se 2: s komplement på 36 (dvs. -36 ) är 11011100 . Detta värde motsvarar det bitvisa komplementet på 35 .
Därför kan vi säga att det bitvisa komplementet på 35 är - (35 + 1) = -36 .
Exempel 3: Bitvis komplement
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-operatörer
Det finns tre typer av skiftoperatörer i Java:
- Signerad vänster skift (<<)
- Signerad högerförskjutning (>>)
- Osignerad högerförskjutning (>>>)
5. Java Left Shift-operatör
Den vänstra skiftoperatören skiftar alla bitar åt vänster med ett visst antal specificerade bitar. Det betecknas med <<.
Java 1 bitars vänster skiftoperatör
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)
Här utför vi rätt skift på 8 (dvs tecken är positivt). Därför finns det inget teckenbit. Så de bitar längst till vänster är fyllda med 0 (representerar positivt tecken).
// 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)
Här har vi använt den signerade biten 1 för att fylla bitarna längst till vänster.
Exempel 6: Signerad höger skiftoperatör
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 Onsigned Right Shift Operator
Java ger också en osignerad högerförskjutning. Det betecknas med >>>.
Här fylls den lediga positionen längst till vänster med 0 istället för teckenbiten. Till exempel,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Exempel 7: UnSigned Right Shift
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 ) )
Som vi kan se returnerar den undertecknade och osignerade högerskiftoperatören olika resultat för negativa bitar. För att lära dig mer, se Skillnaden mellan >> och >>>.
