W tym samouczku dowiemy się o operatorze bitowym i różnych typach operatorów przesunięć w Javie na podstawie przykładów.
W Javie operatory bitowe wykonują operacje na danych całkowitych na indywidualnym poziomie bitowym. Tutaj dane całkowita obejmuje byte, short, intoraz longrodzaje danych.
Istnieje 7 operatorów do wykonywania operacji na poziomie bitów w Javie.
| Operator | Opis |
|---|---|
| | Bitowe OR |
& | Bitowe i |
^ | Bitowe XOR |
~ | Uzupełnienie bitowe |
<< | Lewy Shift |
>> | Podpisany prawy Shift |
>>> | Niepodpisany prawy Shift |
1. Operator bitowy LUB operator Java
Bitowy |operator OR zwraca 1, jeśli przynajmniej jeden z operandów ma wartość 1. W przeciwnym razie zwraca 0.
Poniższa tabela prawdy ilustruje działanie operatora bitowego OR. Niech a i b będą dwoma operandami, które mogą przyjmować tylko wartości binarne, tj. 1 lub 0.
| za | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Powyższa tabela jest nazywana „tablicą prawdy” dla bitowego operatora OR.
Spójrzmy na operację bitową OR na dwóch liczbach całkowitych 12 i 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Przykład 1: bitowe 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. Operator bitowy i operator Java
Operator bitowy AND &zwraca 1 wtedy i tylko wtedy, gdy oba operandy mają wartość 1. W przeciwnym razie zwraca 0.
W poniższej tabeli przedstawiono działanie operatora bitowego AND. Niech a i b będą dwoma operandami, które mogą przyjmować tylko wartości binarne, tj. 1 i 0.
| za | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Przyjrzyjmy się operacji bitowej AND na dwóch liczbach całkowitych 12 i 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Przykład 2: bitowe 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
Bitowy ^operator XOR zwraca 1 wtedy i tylko wtedy, gdy jeden z operandów ma wartość 1. Jednakże, jeśli oba operandy mają wartość 0 lub oba mają wartość 1, wynikiem jest 0.
Poniższa tabela prawdy demonstruje działanie bitowego operatora XOR. Niech a i b będą dwoma operandami, które mogą przyjmować tylko wartości binarne, tj. 1 lub 0.
| za | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Spójrzmy na bitową operację XOR na dwóch liczbach całkowitych 12 i 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Przykład 4: Bitowe 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. Operator dopełniacza bitowego Java
Operator dopełniacza bitowego jest operatorem jednoargumentowym (działa tylko z jednym operandem). Jest oznaczony ~.
Zmienia cyfry binarne 1 na 0 i 0 na 1 .
Operator dopełnienia bitowego 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
Tutaj widzimy, że uzupełnienie 2 do 36 (tj. -36 ) to 11011100 . Ta wartość jest równoważna z bitowym uzupełnieniem 35 .
Dlatego możemy powiedzieć, że bitowe uzupełnienie liczby 35 to - (35 + 1) = -36 .
Przykład 3: dopełnienie bitowe
class Main ( public static void main(String() args) ( int number = 35, result; // bitwise complement of 35 result = ~number; System.out.println(result); // prints -36 ) )
Operatory zmiany Java
W Javie istnieją trzy typy operatorów zmian:
- Podpisany lewy Shift (<<)
- Podpisany prawy Shift (>>)
- Niepodpisany prawy Shift (>>>)
5. Operator Java w lewo
Operator przesunięcia w lewo przesuwa wszystkie bity w lewo o określoną liczbę określonych bitów. Jest oznaczony <<.
Java 1-bitowy operator przesunięcia w lewo
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)
Tutaj wykonujemy przesunięcie w prawo o 8 (czyli znak jest dodatni). Dlatego nie ma żadnego znaku. Więc skrajne lewe bity są wypełnione 0 (reprezentuje znak dodatni).
// 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)
W tym przypadku użyliśmy bitu 1 ze znakiem do wypełnienia skrajnych lewych bitów.
Przykład 6: Podpisany prawy operator zmiany
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 zapewnia również niepodpisane przesunięcie w prawo. Jest oznaczony >>>.
W tym przypadku wolna skrajna lewa pozycja jest wypełniona 0 zamiast bitu znaku. Na przykład,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Przykład 7: Przesunięcie w prawo bez znaku
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 ) )
Jak widać, operator przesunięcia w prawo ze znakiem i bez znaku zwraca różne wyniki dla bitów ujemnych. Aby dowiedzieć się więcej, odwiedź Różnicę między >> i >>>.
