Как работают операторы смены в Java?
Я пытаюсь понять операторов сдвига и не мог получить много.
Когда я попытался выполнить приведенный ниже код
System.out.println(Integer.toBinaryString(2 << 11));
System.out.println(Integer.toBinaryString(2 << 22));
System.out.println(Integer.toBinaryString(2 << 33));
System.out.println(Integer.toBinaryString(2 << 44));
System.out.println(Integer.toBinaryString(2 << 55));
Я получаю ниже
1000000000000
100000000000000000000000
100
10000000000000
1000000000000000000000000
Может кто-нибудь объяснить?
Ответы
Ответ 1
System.out.println(Integer.toBinaryString(2 << 11));
Сдвигает двоичный код 2 (10
) в 11 раз влево. Следовательно: 1000000000000
System.out.println(Integer.toBinaryString(2 << 22));
Сдвигает двоичный код 2 (10
) на 22 раза влево. Следовательно: 100000000000000000000000
System.out.println(Integer.toBinaryString(2 << 33));
Теперь int имеет 4 байта, а значит 32 бита. Поэтому, когда вы сдвигаетесь на 33, это эквивалентно сдвигу на 1. Следовательно: 100
Ответ 2
2 из десятичной системы нумерации в двоичном формате выглядит следующим образом
10
теперь, если вы делаете
2 << 11
было бы, 11 нулей были бы дополнены с правой стороны
1000000000000
Записанный оператор сдвига влево "< сдвигает битовый шаблон влево, а подписанный оператор сдвига вправо" → "сдвигает бит вправо. Битовая диаграмма задается левым операндом, а количество позиций сдвигается правым операндом. Беззнаковый оператор сдвига вправо" → > "сдвигает ноль в крайнее левое положение, а крайняя левая позиция после" → "зависит от расширения знака [.. ]
результаты сдвига слева в умножении на 2 (* 2) в терминах или арифметических
Например
2 в двоичном 10
, если вы <<1
, который будет 100
, который 4
4 в двоичном 100
, если вы <<1
, который будет 1000
, который 8
Также см.
Ответ 3
Работа с правым и левым сдвигом работает так же, как работает Right Shift;
Правый сдвиг:
Оператор правого сдвига, → , сдвигает все биты в значении справа определенное количество раз. Его общий вид:
value >> num
Здесь num указывает количество позиций для смещения значения по значению вправо. То есть, → перемещает все биты в указанном значении вправо, число бит позиций, указанное номером.
Следующий фрагмент кода сдвигает значение 32 вправо на две позиции, в результате чего устанавливается значение 8:
int a = 32;
a = a >> 2; // a now contains 8
Когда значение имеет биты, которые "сдвинуты", эти биты теряются. Например, следующий фрагмент кода сдвигает значение 35 в правые две позиции, что приводит к потере двух младших бит, в результате чего снова устанавливается значение 8.
int a = 35;
a = a >> 2; // a still contains 8
Глядя на ту же операцию в двоичном режиме, более ясно, как это происходит:
00100011 35 >> 2
00001000 8
Каждый раз, когда вы смещаете значение вправо, оно делит это значение на два - и отбрасывает любой остаток. Вы можете воспользоваться этим для высокопроизводительного целочисленного деления на 2. Конечно, вы должны быть уверены, что не сдвигаете ни одного бита с правого конца.
Когда вы смещаетесь вправо, верхние (левые) биты, выставленные правой сменой, заполняются предыдущим содержимым верхнего бита. Это называется расширением знака и служит для сохранения знака отрицательных чисел, когда вы смещаете их вправо. Например, –8 >> 1
- –4
, который в двоичном выражении равен
11111000 –8 >>1
11111100 –4
Интересно отметить, что если вы сдвигаете -1 вправо, результат всегда остается равным -1, так как расширение знака продолжает вносить больше бит в старшие разряды.
Иногда нежелательно значить-расширять значения, когда вы смещаете их вправо. Например, следующая программа преобразует значение байта в шестнадцатеричное представление строки. Обратите внимание, что сдвинутое значение маскируется с помощью ANDing с помощью 0x0f, чтобы отбросить любые биты расширенного знака, чтобы значение могло использоваться как индекс в массиве шестнадцатеричных символов.
// Masking sign extension.
class HexByte {
static public void main(String args[]) {
char hex[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
byte b = (byte) 0xf1;
System.out.println("b = 0x" + hex[(b >> 4) & 0x0f] + hex[b & 0x0f]);
}
}
Вот результат этой программы:
b = 0xf1
Ответ 4
Я считаю, что это может помочь:
System.out.println(Integer.toBinaryString(2 << 0));
System.out.println(Integer.toBinaryString(2 << 1));
System.out.println(Integer.toBinaryString(2 << 2));
System.out.println(Integer.toBinaryString(2 << 3));
System.out.println(Integer.toBinaryString(2 << 4));
System.out.println(Integer.toBinaryString(2 << 5));
Результат
10
100
1000
10000
100000
1000000
Отредактировано:
Должен прочитать это (как делать-бит-сдвиг-сдвиги-работы-работы)
Ответ 5
Я думаю, что это было бы следующим, например:
[2 < 1] is = > [10 (двоичный код из 2) добавить 1 ноль в конце двоичной строки] Следовательно, 10 будет равно 100, что станет 4.
Подписанный сдвиг влево использует умножение...
Таким образом, это также можно было бы рассчитать как 2 * (2 ^ 1) = 4.
Другой пример [ 2 < 11] = 2 * (2 ^ 11) = 4096
[4 → 1] is = > [100 (двоичный код из 4) удаляет 1 ноль в конце двоичной строки] Следовательно, 100 будет равно 10, которое станет 2.
Подписанный сдвиг вправо использует деление...
Таким образом, это также можно было бы рассчитать как 4/(2 ^ 1) = 2
Другой пример [ 4096 → 11] = 4096/(2 ^ 11) = 2
Ответ 6
Он сдвинет биты, заполнив их многими 0's
.
Для ex,
- binary
10
, который является цифрой 2
сдвиг влево на 2, равен 1000
, который является цифрой 8
- binary
10
, который является цифрой 2
, сдвиг влево на 3 равен 10000
, который равен цифре 16
Ответ 7
Смещение может быть реализовано с использованием типов данных (char, int и long int). Сдвиг поплавков и двойных данных сдвигается.
value= value >> steps // Right shift, signed data.
value= value << steps // Left shift, signed data.