Значения сдвинутых битов

String message = "1";
        byte[] bytes = message.getBytes();

        System.out.println(bytes[0] + ": ");
        for (int i = 0; i < 8; i++) {
            System.out.print((bytes[0] >> (7 - i)) + " ");
        }

Output: 49: 
0 0 1 3 6 12 24 49

Так что моя строка 1 который в ASCII является 49, Я пытаюсь понять, почему мои биты имеют значения 3,6,12,24 и 49? Что происходит позади, почему они не только 0 и 1, как первые 3?

Источник

5 ответов

Решение

49 в двоичном

110001

Вы сдвигаете это же значение на 7, 6, 5, 4, ..., (7 - i) биты.

Так

00110001 >> 7 ==> 00000000 == 0
00110001 >> 6 ==> 00000000 == 0
00110001 >> 5 ==> 00000001 == 1
00110001 >> 4 ==> 00000011 == 3
...

Ты можешь использовать Integer.toBinaryString(int) чтобы получить двоичное представление целочисленного значения в виде String,

Источник

Потому что ваше извлечение битов неверно. Битовое представление для символа '1' это из 49: 00110001,

Вы сдвигаетесь 7 раз, затем 6, затем 5 и т. Д., Но вы неправильно изолируете биты.

00110001 >> 7 is 00000000 or 0
00110001 >> 6 is 00000000 or 0
00110001 >> 5 is 00000001 or 1
00110001 >> 4 is 00000011 or 3
00110001 >> 3 is 00000110 or 6
00110001 >> 2 is 00001100 or 12
00110001 >> 1 is 00011000 or 24
00110001 >> 0 is 00110001 or 49

Вы должны сделать побитовый - и с 1 чтобы выделить бит, который вы сдвинули, чтобы получить 1 и 0.

System.out.print( ((bytes[0] >> (7 - i)) & 1) + " ");

Выход:

49: 
0 0 1 1 0 0 0 1
Источник

Последние 8 бит числа 49 в двоичном виде выглядит так:

00110001

Когда вы сдвигаете число прямо на k биты, это то же самое, что делить его на int на 2тыс. Это то, что вы получаете на выходе (цифры справа от | упали):

0 | 0110001 -- 0
00 | 110001 -- 0
001 | 10001 -- 1
0011 | 0001 -- 3
00110 | 001 -- 6
001100 | 01 -- 12
0011000 | 1 -- 24
00110001 |  -- 49
Источник

При сдвиге сдвигаешь биты n позиции (в данном случае справа).

Так:

Loop#    7-i     bits      result
0        7      000000000   0
1        6      000000000   0
2        5      000000001   1
3        4      000000011   3
4        3      000000110   6
5        2      000001100  12
6        1      000011000  24
7        0      000110001  49

Причина, по которой первые смены 0 а также 1 это потому, что все значимые биты уже были удалены.

Если вы хотите получить последний бит, вам нужно выполнить (a>>s)&1 с a число и s немного справа вы хотите.

Если вы хотите распечатать двоичное представление aВы можете просто использовать Integer.toBinaryString(a);

Источник

Ваши фактические данные могут быть 49, но для байтовых типов данных они должны заполнять 8 бит. Итак, если вы считаете 8 бит, начиная с 0 до 7 (согласно циклу). И вы используете >> который сместится вправо.

49 binary is  0 0 1 1 0 0 0 1

0 0 1 1 0 0 0 1  >> 7-0 = 00000000 = 0
0 0 1 1 0 0 0 1  >> 7-1 = 00000000 = 0
0 0 1 1 0 0 0 1  >> 7-2 = 00000001 = 1
0 0 1 1 0 0 0 1  >> 7-3 = 00000011 = 3
0 0 1 1 0 0 0 1  >> 7-4 = 00000110 = 6
0 0 1 1 0 0 0 1  >> 7-5 = 00001100 = 12
0 0 1 1 0 0 0 1  >> 7-6 = 00011000 = 32
0 0 1 1 0 0 0 1  >> 7-7 = 00110001 = 49
Источник
Другие вопросы по тегам