Ebben az oktatóanyagban példák segítségével megismerhetjük a Java bitenkénti operátorát és a váltási operátorok különféle típusait.
A Java-ban a bitenkénti operátorok egész bitadatokkal végeznek műveleteket az egyes bitszinteken. Itt, az egész adat tartalmaz byte, short, int, és longtípusú adatok.
7 operátor végez bitszintű műveleteket a Java-ban.
| Operátor | Leírás |
|---|---|
| | Bitenként VAGY |
& | Bitenkénti ÉS |
^ | Bitenként XOR |
~ | Bitenkénti kiegészítés |
<< | Bal Shift |
>> | Aláírt jobb váltás |
>>> | Aláíratlan jobb váltás |
1. Java bitenként VAGY Operator
A bitenként OR |operátor 1-et ad vissza, ha az operandusok közül legalább az egyik 1. Ellenkező esetben 0-t ad vissza.
Az alábbi igazságtáblázat bemutatja a bitenkénti OR operátor működését. Legyen a és b két olyan operandus, amelyek csak bináris értékeket vehetnek fel, azaz 1 vagy 0.
| a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
A fenti táblázat a bitenkénti VAGY operátor "Igazság táblája" néven ismert.
Nézzük meg a 12 és 25 egész szám bitenkénti VAGY műveletét.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
1. példa: Bitenként vagy VAGY
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 bitenként ÉS operátor
A bitenkénti AND &operátor akkor és akkor ad vissza 1-t, ha mindkét operandus 1. Ellenkező esetben 0-t ad vissza.
Az alábbi táblázat bemutatja a bitenkénti ÉS operátor működését. Legyen a és b két olyan operandus, amelyek csak bináris értékeket vehetnek fel, azaz 1 és 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Vessünk egy pillantást két egész szám bitenkénti ÉS műveletére.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
2. példa: Bitenkénti ÉS
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
A bitenkénti XOR ^operátor akkor és akkor ad vissza 1-t, ha az egyik operandus 1. Azonban, ha mindkét operandus 0 vagy ha mindkettő 1, akkor az eredmény 0.
Az alábbi igazságtáblázat bemutatja a bitenkénti XOR operátor működését. Legyen a és b két olyan operandus, amelyek csak bináris értékeket vehetnek fel, azaz 1 vagy 0.
| a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Nézzük meg két egész szám 12 és 25 bitenkénti XOR műveletét.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
4. példa: Bitenként 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 bitenkénti kiegészítő operátor
A bitenkénti komplementer operátor unáris operátor (csak egy operandummal működik). Jelöli ~.
Megváltoztatja bináris számjegy 1- , hogy 0 és 0 , hogy 1- .
Java bitenkénti kiegészítő operátor
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
Itt láthatjuk, hogy a 36-os (azaz -36 ) 2-es kiegészítése 11011100 . Ez az érték megegyezik a 35 bitenkénti kiegészítésével .
Ezért, azt mondhatjuk, hogy a bitenkénti komplementerét 35 jelentése - (35 + 1) = -36 .
3. példa: Bitenkénti kiegészítés
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 Operátorok
A Java-ban háromféle műszakoperátor létezik:
- Aláírt bal váltás (<<)
- Aláírt jobb váltás (>>)
- Aláíratlan jobb váltás (>>>)
5. Java bal váltás operátor
A bal váltás operátora az összes bitet bizonyos számú megadott bit által balra tolja. Jelöli <<.
Java 1 bites bal váltás operátor
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)
Itt a 8- as jobb eltolást hajtjuk végre (azaz a jel pozitív). Ezért nincs semmi jel. Tehát a bal szélső bitek 0- val vannak kitöltve (pozitív előjelet képvisel).
// 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)
Itt az aláírt 1. bitet használtuk a bal szélső bitek kitöltésére.
6. példa: Aláírt jobb váltó kezelő
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 előjel nélküli jobb váltás operátor
A Java előjel nélküli jobb váltást is biztosít. Jelöli >>>.
Itt a megüresedett bal szélső pozíció 0- val van kitöltve a jelbit helyett. Például,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
7. példa: Jel nélküli jobb váltás
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 ) )
Amint láthatjuk, az aláírt és az aláíratlan jobbra váltás operátora eltérő eredményeket ad negatív bitekre. További információért keresse fel a >> és >>> közötti különbséget.
