Почему так работают битовые сдвиги в Java?

Question

[Biaci_Anj]

Представим, что у нас задача поместить единицу на 1 место и 63 нуля после.
Т.е. сделать что-то такое 1
1000000000000000000000000000000000000000000000000000000000000000

Вот к примеру, попробуем мы 1 сместить на 64 позиции.

long result = (long) 1 << 64;
        System.out.println(Long.toBinaryString(result)); // получаем единицу, логично. Long положительный может иметь 63 разряда.

Попробуем обойти эту проблему

long result2 = (long) 128 << 56;
        System.out.println(Long.toBinaryString(result2));

И получаем необходимый результат
1000000000000000000000000000000000000000000000000000000000000000
Сдвиг 128 на 56 раз помещает единицу на 64 место.

Вопрос, почему мы можем это сделать методом выше, а просто 1 << 64 никак?

Answer 1

[Vamp]

Битовый сдвиг для типа long не может превышать 63. Поэтому сдвиг 1L << 64 будет преобразован jvm в 1L << (64 & 0x3f), в результате чего получается 1L << 0 и поэтому у вас значение не изменяется.

Вашу задачу решает сдвиг 1L << 63. Единица изначально находится на 1 позиции (позиции нумеруются справа налево) и сдвигается влево на 63 позиции. Вы получаете желаемую единицу на 64 позиции с 63 нулями позади.

Что касается 128L << 56, то здесь всё корректно и логично. Единица находится на 8 позции и имеет 7 нулей сзади. Сдвигая её на 56 позиций, у вас получается желаемый результат - единица на 64 позиции (8 + 56) и 63 нуля позади (7 нулей + 56).

Answer 2

[Дмитрий Беляев]

Потому что 1 << 64 != 128 << 56, и вообще 1 << 64 в 64 бита не влазит

Comments

[Biaci_Anj]

Благодарю за ответ, к сожалению, не до конца понял.
1 << 63 - переносим единицу 63 раза влево, 1 << 64 уже не работает, действительно, не влазит, идем по кругу.
Но
128 = 1 восьмая справа, мы ее переносим на 56 раз.

56 + 8 = 64 и она действительно оказывается 64-й.
Почему 128 << 56 != 1 << 64?
Прошу прощения, но я действительно пытаюсь понять, 64 бит же должен влазить, если число отрицательное и он тут и влазит, а в 1 << 64 нет ( считает число положительным ).

[Дмитрий Беляев]

128 = 1 восьмая справа, мы ее переносим на 56 раз.

56 + 8 = 64 и она действительно оказывается 64-й.

Biaci_Anj, на самом деле 128 соответствует 7 биту, а не 8, так как отсчет идет с 0. То есть получается 56 + 7 = 63.

Смотрите как это работает:
1: 2⁰ == 1 << 0
2: 2¹ == 1 << 1
4: 2² == 1 << 2
8: 2³ == 1 << 3
...
128: 2⁷ == 1 << 7

Answer 3

[profesor08]

Переполнение же. К языку особого отношения не имеет, так работает память, когда для какого-то значения выделено ее ограниченное количество. Почитай про это и вопросы отпаду довольно быстро.