Как работают операторы смены в Java?

Ответ 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

Также см.

• absolute-beginners-guide-to-bit-shifting

Ответ 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.