В этом руководстве мы узнаем о побитовом операторе и различных типах операторов сдвига в Java с помощью примеров.
В Java побитовые операторы выполняют операции с целочисленными данными на индивидуальном битовом уровне. Здесь, целое число данные включают в себя byte, short, intи longтипах данных.
В Java есть 7 операторов для выполнения битовых операций.
| Оператор | Описание |
|---|---|
| | Побитовое ИЛИ |
& | Побитовое И |
^ | Побитовое исключающее ИЛИ |
~ | Побитовое дополнение |
<< | Левый "шифт |
>> | Подпись Right Shift |
>>> | Беззнаковый сдвиг вправо |
1. Оператор побитового ИЛИ Java
Побитовый |оператор ИЛИ возвращает 1, если хотя бы один из операндов равен 1. В противном случае он возвращает 0.
Следующая таблица истинности демонстрирует работу побитового оператора ИЛИ. Пусть a и b - два операнда, которые могут принимать только двоичные значения, например 1 или 0.
| а | б | а | б |
|---|---|---|
| 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.
Следующая таблица демонстрирует работу побитового оператора AND. Пусть a и b - два операнда, которые могут принимать только двоичные значения, то есть 1 и 0.
| а | б | а и б |
|---|---|---|
| 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. Побитовый оператор XOR в Java
Побитовый ^оператор XOR возвращает 1 тогда и только тогда, когда один из операндов равен 1. Однако, если оба операнда равны 0 или если оба равны 1, то результатом будет 0.
Следующая таблица истинности демонстрирует работу побитового оператора XOR. Пусть a и b - два операнда, которые могут принимать только двоичные значения, например 1 или 0.
| а | б | а и б |
|---|---|---|
| 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: Побитовое исключающее ИЛИ
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
Здесь мы видим, что двойное дополнение к 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
В Java есть три типа операторов сдвига:
- Подпись Left Shift (<<)
- Подпись вправо Shift (>>)
- Беззнаковый сдвиг вправо (>>>)
5. Оператор левого сдвига в Java
Оператор сдвига влево сдвигает все биты влево на определенное количество заданных битов. Обозначается он <<.
1-битный оператор сдвига влево в Java
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
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 ) )
Как мы видим, знаковый и беззнаковый оператор сдвига вправо возвращает разные результаты для отрицательных битов. Чтобы узнать больше, посетите раздел Разница между >> и >>>.
