Оператор сдвига вправо & gt; & gt;, сдвигает все биты в значении вправо на указанное число раз. Его общая форма: значение & gt; & gt; Num Здесь num указывает количество позиций для сдвига вправо значения в значении. То есть & gt; & gt; перемещает все биты в указанном значении вправо на количество битовых позиций, указанных в num. Следующий фрагмент кода сдвигает значение 32 вправо на две позиции, в результате чего устанавливается значение 8:

int a = 32;
a = a >> 2; // a now contains 8

Когда значение имеет биты, которые & # x201C; смещены, & # x201D; эти биты потеряны. Например, следующий фрагмент кода сдвигает значение 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

Интересно отметить, что если вы сдвинете вправо & # x2013; 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

это правильный битовый сдвиг. Вы увидите это во многих из так называемых «C-стилей» языки.

Чтобы получить подробную информацию о сдвиге битов, предоставленную другими пользователями StackOverflow, ознакомьтесь с вопросом, который я опубликовал много лет назад, и который помог мне наконец получить его:Руководство абсолютного новичка по бит-смещению, (Люди, которые опубликовали там, были достаточно любезны, чтобы углубиться в предмет, который, я надеюсь, поможет вам также.)

>> оператор - оператор побитового сдвига вправо.

Простой пример:

int i = 4;
System.out.println(i >> 1); // prints 2 - since shift right is equal to divide by 2
System.out.println(i << 1); // prints 8 - since shift left is equal to multiply by 2

Отрицательные числа ведут себя одинаково:

int i = -4;
System.out.println(i >> 1); // prints -2
System.out.println(i << 1); // prints -8

Вообще говоря -i << k эквивалентноi*(2^k), в то время какi >> k эквивалентноi/(2^k).

Во всех случаях (как и с любым другим арифметическим оператором) вы всегда должны следить за тем, чтобы не переполнять тип данных.

что это оператор сдвига битов. Как и в ходах все 1 и 0 на одну позицию вправо. (Я думаю, вы можете представить, что & lt; & lt; делает ... :))

вот некоторая информация ооператоры Java

Например

101  = 5
Shifting out the right "1"
10 = 2
Shifting the other way...
1010 = 10