V tomto tutoriále sa pomocou príkladov dozvieme o bitových operátoroch a rôznych typoch operátorov posunov v Jave.
V Jave bitové operátory vykonávajú operácie s celočíselnými údajmi na individuálnej bitovej úrovni. Tu sa dáta celé číslo zahŕňa byte, short, inta longtypy dát.
Existuje 7 operátorov, ktorí vykonávajú operácie na bitovej úrovni v Jave.
| Prevádzkovateľ | Popis |
|---|---|
| | Bitové ALEBO |
& | Bitové AND |
^ | Bitový XOR |
~ | Bitový doplnok |
<< | Lavy shift |
>> | Podpísaný pravý posun |
>>> | Nepodpísaný pravý posun |
1. Java bitový operátor OR
Bitový |operátor OR vráti 1, ak aspoň jeden z operandov je 1. V opačnom prípade vráti 0.
Nasledujúca tabuľka pravdy demonštruje prácu bitového operátora OR. Nech a a b sú dva operandy, ktoré môžu nadobúdať iba binárne hodnoty, tj. 1 alebo 0.
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Vyššie uvedená tabuľka je známa ako „tabuľka pravdy“ pre bitový operátor OR.
Pozrime sa na bitovú operáciu ALEBO dvoch celých čísel 12 a 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Príklad 1: Bitové ALEBO
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 bitový operátor AND
Bitový &operátor AND vráti 1, len ak sú oba operandy 1. V opačnom prípade vráti 0.
Nasledujúca tabuľka demonštruje prácu bitového operátora AND. Nech a a b sú dva operandy, ktoré môžu nadobúdať iba binárne hodnoty, tj. 1 a 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Pozrime sa na bitovú operáciu AND dvoch celých čísel 12 a 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Príklad 2: Bitový operátor 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. Operátor Java Bitwise XOR
Bitový ^operátor XOR vráti 1 práve vtedy, ak je jeden z operandov 1. Ak sú však oba operandy 0 alebo ak sú oba 1, potom je výsledok 0.
Nasledujúca tabuľka pravdy demonštruje prácu bitového operátora XOR. Nech a a b sú dva operandy, ktoré môžu nadobúdať iba binárne hodnoty, tj. 1 alebo 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Pozrime sa na bitovú operáciu XOR dvoch celých čísel 12 a 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Príklad 4: Bitový 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. Operátor Java Bitwise Complement
Operátor bitového doplnku je unárny operátor (pracuje iba s jedným operandom). Označuje to ~.
Mení binárne číslice 1 až 0 a 0 až 1 .
Operátor bitových doplnkov Java
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
Tu môžeme vidieť doplnok! 2 z 36 (tj -36 ) je 11011100 . Táto hodnota je ekvivalentná bitovému doplnku 35 .
Môžeme teda povedať, že bitový doplnok 35 je - (35 + 1) = -36 .
Príklad 3: Bitový doplnok
class Main ( public static void main(String() args) ( int number = 35, result; // bitwise complement of 35 result = ~number; System.out.println(result); // prints -36 ) )
Operátori Java Shift
V Jave existujú tri typy operátorov posunu:
- Podpísaný ľavý posun (<<)
- Podpísaný pravý posun (>>)
- Nepodpísaný pravý posun (>>>)
5. Operátor ľavého posuvu Java
Operátor ľavého posunu posúva všetky bity smerom doľava o určitý počet zadaných bitov. Označuje to <<.
Operátor ľavého posunu Java 1 bit
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)
Tu vykonávame správny posun 8 (tj znamienko je pozitívne). Preto tu nie je ani znak. Bity úplne vľavo sú teda vyplnené 0 (predstavuje kladné znamienko).
// 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)
Tu sme použili podpísaný bit 1 na vyplnenie bitov úplne vľavo.
Príklad 6: Podpísaný operátor pravého radenia
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 Unsigned Right Shift Operator
Java tiež poskytuje nepodpísaný posun vpravo. Označuje to >>>.
Tu je prázdna pozícia úplne vľavo naplnená 0 namiesto znakového bitu. Napríklad,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Príklad 7: Nepodpísaný pravý posun
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 ) )
Ako vidíme, operátor posunu s podpisom a bez znamienka vráti rôzne výsledky pre záporné bity. Ak sa chcete dozvedieť viac, navštívte rozdiel medzi >> a >>>.
