Двоичное представление в Java

Question

Мне трудно понять и работать с этим двоичным представлением в java:

С помощью пользователя Jon Skeet я понял, что двоичное представление должно быть построено таким образом.

Вот пример кода:

public class chack {

public static void main(String[] args) {
    int num2=2;
    int num3=3;
    int num4=4;
    int num1=1;
    int nirbinary = (num1 << 24) | (num2 << 16) | (num3 << 8) | num4;
    System.out.println(nirbinary);
    String nir=  Integer.toBinaryString(nirbinary);
    System.out.println(nir);
    }
}

Пара вопросов:

1. Как получить num1 (например) от int, который уже находится в этом двоичном файле
2. почему я получаю 16909060, когда печатаю nirbinary - что это означает?Как можно получить num1 (например) от int, который уже находится в этом двоичном представлении?

Спасибо

Answer 1

Я не совсем уверен, чего вам не хватает, поэтому я просто объясню, как вы можете конвертировать целые числа в двоичные строки вперед и назад в Java.

Вы можете получить двоичную строку из целого числа, например:

int i = 1234;
String binString = Integer.toBinaryString(i);

и вы можете преобразовать строку обратно в целое число следующим образом:

int iNew = Integer.parseInt(binString, 2);

Обратите внимание, что вторым аргументом Integer.parseInt () является желаемое основание числа. 2 - двоичное, 8 - восьмеричное, 10 - десятичное и т. Д.

Answer 2

16909060 обозначает номер 16909060.

Это (1 * 2 ²⁴ ) + (2 * 2 ¹⁶ ) + (3 * 2 ⁸ ) + 4 .

Чтобы вернуть num1, просто сдвиньте результат вправо на ту же величину, на которую вы сдвинули влево, и замаскируйте другие байты (не всегда необходимо для num1 ^(*) , но для остальные):

int num1 = nirbinary >> 24 & 0xFF;
int num2 = nirbinary >> 16 & 0xFF;
int num3 = nirbinary >> 8 & 0xFF;
int num4 = nirbinary & 0xFF;

Обратите внимание, что nirbinary не является "двоичным представлением". Или точнее: он не более или менее двоичный, чем num1, num2, num3 и num4: внутренне все числа (и символы, и логические значения, ...) хранятся в двоичном формате.

(*) обратите внимание, что если num1> 127, то вам либо необходимо использовать >>>, чтобы сделать сдвиг вправо или , использовать & 0xFF в Чтобы убедиться, что правильное значение восстановлено. Разница между >> и >>> заключается в «новых» битах, вставленных в «левую» часть значения: при >> они будут зависеть от бита с наибольшим значением (известного как расширение знака) и при >>> они всегда будут 0.

Answer 3

Здесь нет необходимости зависеть только от двоичного или любого другого формата ... доступна одна гибкая встроенная функция, которая печатает любой формат, который вы хотите в вашей программе ..

Integer.toString(int,representation);

Integer.toString(100,8)   // prints 144 --octal representation

Integer.toString(100,2)  // prints 1100100 --binary representation

Integer.toString(100,16) //prints 64  --Hex representation

Integer.toString(100,5) // prints 400  --Base 5

Answer 4

При работе с битами и целыми числами я бы порекомендовал вам думать в шестнадцатеричных числах, что обычно значительно облегчает жизнь. Просто имейте в виду, что 8 бит представляют 1 байт, а 1 байт покрывает шестнадцатеричный диапазон от 0x00 до 0xFF

Поскольку числа от num1 до num4 меньше 10, их десятичное представление равно их шестнадцатеричному представлению, то есть 1 = 0x01, 2 = 0x02 и т. Д. Как я уже говорил: 1 байт равен 8 битам. В вашей операции сдвига битов вы всегда сдвигаете кратное 8.

• Итак 0x01 << 8 => 0x0100
• 0x01 << 16 => 0x010000
• и т.д.

Таким образом, вы в основном добавляете только ноль байтов, что, конечно, увеличивает значение. Что вы делаете дальше, чтобы | их, побитовой или. Это означает, что два битовых поля модифицируются таким образом, что результат имеет 1 в одном месте, если хотя бы одно из входных значений равно 1. Поскольку ваши сдвинутые целые числа содержат только ноль сзади, побитовый или нет ничего, чтобы поставить значение в этом месте. Например:

(0x01 << 8) | 0x02

0x01 << 8 даст 0x0100. Теперь вам просто нужно заменить последние 00 на 02, так как вы или они: 0x0102

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

например. Скажем, вы произвели 0x010203 и хотите иметь только 0x02. Теперь вам нужно замаскировать смещение назад 0x010203 >> 8, что поместит 02 в последнюю часть. Теперь просто замаскируйте эту последнюю часть 0x0102 && 0xFF. Это установит все, кроме последних 8 бит, в ноль

Answer 5

Каждый int - это число, это не двоичное, шестнадцатеричное или десятичное число, это просто число. оператор (num1 << 24) | (num2 << 16) | (num3 << 8) | num4; представляет собой двоичную манипуляцию 4 int s в другой тип int. Он не меняет представление nirbinary на двоичное, поскольку nirbinary не имеет представления, потому что (опять же) это просто число.

Integer.toBinaryString(nirbinary) возвращает двоичное представление nirbinary, что означает "как будет выглядеть nibinary в base-2".

Если у вас есть String, представляющая двоичное представление числа, вы можете получить его значение, используя Integer.parseint(yourbinaryrepresentation, yourbase);, например - Integer.parseint(nir, 2);

И еще одна вещь:

Вы не всегда можете вернуть одно из чисел обратно из nirbinary, так как вы выполнили необратимые манипуляции с битами, например:

int i1 = 5;   //binary 0101
int i2 = 4;   //binary 0100
int i3 = i1 | i2;  //binary 0101

вы не можете распознать каждую из ваших переменных (i1, i2), так как они имеют общий бит, i3 мог быть результатом or на двух других числах:

int i1 = 1;   //binary 0101
int i2 = 4;   //binary 0100
int i3 = i1 | i2;  //binary 0101

в вашем случае, , если каждое число меньше 256, вы можете изменить его, выполнив следующую операцию:

int myoldnumber = (nirbinary >> previousShift) & 0xff;

например, чтобы получить num1, вы можете сделать:

int retrievedNum1 = (nirbinary >> 24) & 0xff;

Answer 6

1. Что вы ожидали вместо этого?
2. Чтобы получить самый старший байт от int i:

(i >> 24) & 0xff

Answer 7

1. это в основном 1 * 2^24 + 2 * 2^16 + 3 * 2^8 + 4 = 16909060
2. Вы можете получить num1, выполнив num1 = nirbinary >> 24.