Как работают операторы сдвига в Java? [Дубликат]

На этот вопрос уже есть ответ:

Каковы операторы побитового сдвига (bit-shift) и как они работают? 8 ответов

Я пытаюсь понять операторов смены и не могу получить много. Когда я пытался выполнить приведенный ниже код

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    

Может кто-нибудь объяснить, пожалуйста?

Ответы на вопрос(9)

int и long int). Поплавок и двойные данные не могут быть сдвинуты.

value= value >> steps  // Right shift, signed data.
value= value << steps  // Left shift, signed data.

    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

Edited:

Обязательно прочтите (как работают операторы сдвига)

Подпись вле Логически просто, если 1 << 11 будет стремиться к 2048, а 2 << 11 даст 4096

В Java-программировании int a = 2 << 11;

// it will result in 4096

2<<11 = 2*(2^11) = 4096
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

переписать с помощью сокращенных операторов << =, >> =, или = @ >>&g, также известный в спецификации как Составные операторы присваивания.

Например

i >>= 2

производит тот же результат, что и

i = i >> 2

бразом

10

теперь, если ты сделаешь

2 << 11

было бы, 11 нулей были бы дополнены на правой стороне

1000000000000

Оператор сдвига влево со знаком «<<» сдвигает битовую комбинацию влево, а оператор сдвига влево со знаком «>>» сдвигает битовую комбинацию вправо. Битовая комбинация задается левым операндом, а число позиций для смещения - правым операндом. Оператор сдвига без знака «>>>» смещает ноль в крайнее левое положение, а крайнее левое положение после «>>» зависит от расширения знака [..]

двиг влево приводит к умножению на 2 (* 2) в терминах или арифметике

Наприме

2 в двоичном10, если ты сделаешь<<1 это было бы100 который4

4 в двоичном100, если ты сделаешь<<1 это было бы1000 который8

Также с

абсолютные новички-гид-к-битового сдвиг

вот как работает правое смещение; Сдвиг вправо: Оператор сдвига вправо, >>, сдвигает все биты в значении вправо на указанное число раз. Его общая форма:

value >> num

Здесь, 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, поскольку расширение знака продолжает вводить больше единиц в старших разрядах. Иногда нежелательно подписывать значения-расширения, когда вы сдвигаете их вправо. Например, следующая программа преобразует значение байта в его шестнадцатеричное строковое представление. Обратите внимание, что смещенное значение маскируется с помощью AND с 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

Подпись вле

[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

0's.

Для бывших,

binary10 которая является цифрой2 сдвиг влево на 2 - это1000 которая является цифрой8binary10 которая является цифрой2 сдвиг влево на 3 - это10000 которая является цифрой16

ВАШ ОТВЕТ НА ВОПРОС