В този урок ще научим за битовия оператор и различните видове оператори на смяна в Java с помощта на примери.
В Java побитовите оператори извършват операции с целочислени данни на индивидуално битово ниво. Тук данни число включва byte, short, intи longтипове данни.
Има 7 оператора за извършване на операции на битово ниво в Java.
| Оператор | Описание |
|---|---|
| | Побитово ИЛИ |
& | Побитово И |
^ | Побитово XOR |
~ | Побитово допълнение |
<< | Лява смяна |
>> | Подписано дясна смяна |
>>> | Неподписана дясна смяна |
1. Java побитови ИЛИ Оператор
Побитовият |оператор OR връща 1, ако поне един от операндите е 1. В противен случай връща 0.
Следващата таблица на истината демонстрира работата на битовия оператор ИЛИ. Нека a и b са два операнда, които могат да приемат само двоични стойности, т.е. 1 или 0.
| а | б | a | б |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Горната таблица е известна като "таблица на истината" за битовия оператор ИЛИ.
Нека разгледаме битовата ИЛИ операция на две цели числа 12 и 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) Bitwise OR Operation of 12 and 25 00001100 | 00011001 ____________ 00011101 = 29 (In Decimal)
Пример 1: Побитово ИЛИ
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 побитови И Оператор
Побитовият &оператор И връща 1, ако и само ако и двата операнда са 1. В противен случай връща 0.
Следващата таблица демонстрира работата на битовия оператор И. Нека a и b са два операнда, които могат да приемат само двоични стойности, т.е. 1 и 0.
| а | б | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Нека да разгледаме битовата И операция на две цели числа 12 и 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise AND Operation of 12 and 25 00001100 & 00011001 ____________ 00001000 = 8 (In Decimal)
Пример 2: Побитово И
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 побитов XOR оператор
Побитовият XOR ^оператор връща 1, ако и само ако един от операндите е 1. Ако обаче и двата операнда са 0 или ако и двата са 1, резултатът е 0.
Следващата таблица на истината демонстрира работата на битовия XOR оператор. Нека a и b са два операнда, които могат да приемат само двоични стойности, т.е. 1 или 0.
| а | б | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Нека да разгледаме битовата XOR операция на две цели числа 12 и 25.
12 = 00001100 (In Binary) 25 = 00011001 (In Binary) // Bitwise XOR Operation of 12 and 25 00001100 00011001 ____________ 00010101 = 21 (In Decimal)
Пример 4: Побитов 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
Побитовият оператор на допълнение е унарен оператор (работи само с един операнд). Обозначава се с ~.
Той променя двоичните цифри 1 на 0 и 0 на 1 .
Оператор за битово допълване на 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
Тук можем да видим допълнението на 2 от 36 (т.е. -36 ) е 11011100 . Тази стойност е еквивалентна на битовото допълнение на 35 .
Следователно можем да кажем, че битовото допълнение на 35 е - (35 + 1) = -36 .
Пример 3: Побитово допълнение
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 Оператори
В Java има три вида оператори на смяна:
- Подписана лява смяна (<<)
- Подписана дясна смяна (>>)
- Неподписана дясна смяна (>>>)
5. Java Left Shift Operator
Операторът за лява смяна измества всички битове наляво с определен брой определени битове. Обозначава се с <<.
Java 1 битов оператор за лява смяна
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)
Тук изпълняваме правилната смяна на 8 (т.е. знакът е положителен). Следователно, няма знаков бит. Така че най-левите битове се запълват с 0 (представлява положителен знак).
// 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)
Тук използвахме подписания бит 1, за да запълним най-левите битове.
Пример 6: Подписан оператор за дясна смяна
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 Shift Operator
Java също осигурява неподписана дясна смяна. Обозначава се с >>>.
Тук свободната най-лява позиция се запълва с 0 вместо със знаковия бит. Например,
// unsigned right shift of 8 8 = 1000 8>>> 2 = 0010 // unsigned right shift of -8 -8 = 1000 (see calculation above) -8>>> 2 = 0010
Пример 7: Неподписана дясна смяна
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 ) )
Както виждаме, подписаният и неподписаният оператор за дясна смяна връща различни резултати за отрицателни битове. За да научите повече, посетете Разликата между >> и >>>.
