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

2 из десятичной системы счисления в двоичной выглядит следующим образом

10

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

2 << 11

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

1000000000000

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

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

---

2 в двоичном 10, Если у вас <<1 что будет 100 что это 4

4 двоичный 100, если у вас <<1 это было бы 1000 что это 8

---

См. Также

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

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

value >> num

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

Я считаю, что это может помочь:

    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

редактировать:

должен прочитать это (как-делать-побитовый-сдвиг-операторы-работа)

Я думаю, что это будет следующее, например:

• знаковый сдвиг влево

[ 2 [10 (двоичный из 2) добавить 1 ноль в конце двоичной строки] следовательно, 10 будет 100, который становится 4.

знаковый сдвиг влево использует умножение... Так это также может быть рассчитан как 2 * (2^1) = 4. Другой пример [2 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.

например,

• binary 10 что цифры 2 сдвиг влево на 2 1000 что цифры 8
• binary 10 что цифры 2 сдвиг влево на 3 10000 что цифры 16

сдвиг может быть реализован с типами данных (char, int и long int). Коннот поплавка и двойных данных был перенесен.

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

знаковый сдвиг влево Логически Просто, если 1

в программировании на java int a = 2

// it will result in 4096

2<<11 = 2*(2^11) = 4096

типичное использование сдвига переменной и присвоение переменной может быть переписано с помощью стенографических операторов ,>>= или >>>=, также известный в спецификации как Составные Операторы Присваивания.

например,

i >>= 2

аналогично

i = i >> 2