Как целые числа преобразуются в байты в Java?

Question

Я знаю, что Java не допускает неподписанные типы, поэтому мне было интересно, как он преобразует целое число в байт. Скажем, у меня есть целое число a со значением 255, и я приведу целое число к байту. Значение представлено в байте 11111111? Другими словами, рассматривается ли значение больше как 8-разрядное целое число со знаком или оно просто напрямую копирует последние 8 битов целого числа?

Answer 1

Это называется сужающим примитивным преобразованием . Согласно спецификации:

Сужающее преобразование целого числа со знаком в целочисленный тип T просто отбрасывает все биты, кроме n младших битов, где n - количество бит используется для представления типа T . Помимо возможной потери информации о величине числового значения, это может привести к тому, что знак полученного значения будет отличаться от знака входного значения.

Так что это второй вариант, который вы перечислили (напрямую копируя последние 8 бит).

Я не уверен в вашем вопросе, знаете ли вы о том, как представлены целочисленные значения со знаком, так что для безопасности я укажу, что значение байта 1111 1111 равно -1 в двух. дополняет систему (которую использует Java).

Answer 2

int i = 255;

byte b = (byte)i;

Таким образом, значение в шестнадцатеричном формате равно 0xFF, а десятичное значение будет равно -1.

int i = 0xff00;

byte b = (byte)i;

Значение b теперь равно 0x00. Это показывает, что Java берет последний байт целого числа. то есть. последние 8 бит, но это подписано.

Answer 3

или просто копирует последний 8 битов целого числа

да, так работает этот кастинг

Answer 4

Байт равен 8 битам. 8 бит может представлять 256 чисел. (От 2 до 8 = 256)
Теперь первый бит используется для знака. [если положительный, то первый бит = 0, если отрицательный первый бит = 1]
допустим, вы хотите преобразовать целое число 1099 в байт. просто делим 1099 на 256. Остаток - это ваше байтовое представление типа int
примеры
1099/256 => остаток = 75
-1099/256 => остаток = -75
2049/256 => остаток = 1
Причина, почему? посмотрите на это изображение http://i.stack.imgur.com/FYwqr.png

Answer 5

Согласно моему пониманию, вы имели в виду

Integer i=new Integer(2);
byte b=i;   //will not work 

final int i=2;
byte b=i;   //fine 

Наконец

Byte b=new Byte(2);
int a=b;   //fine

Answer 6

Просто подумайте над тем, что сказано: всегда маскируйте свое целое число при преобразовании в байты с помощью 0xFF (для целых чисел). (Предполагая, что myInt были присвоены значения от 0 до 255).

например.

char myByte = (char)(myInt & 0xFF);

почему? если myInt больше 255, просто приведение типа к байту возвращает отрицательное значение (дополнение 2), которое вам не нужно.

Answer 7

for (int i=0; i <= 255; i++) {
    byte b = (byte) i;    // cast int values 0 to 255 to corresponding byte values 
    int neg = b;     // neg will take on values 0..127, -128, -127, ..., -1
    int pos = (int) (b & 0xFF);  // pos will take on values 0..255
}

Преобразование байта, который содержит значение больше 127 (т.е. значения от 0x80 до 0xFF), в int приводит к расширению знака старшего бита значения байта (то есть, бит 0x80). Чтобы удалить лишние биты, используйте x & 0xFF; это устанавливает биты выше 0x80 (то есть биты 0x100, 0x200, 0x400, ...) в ноль, но оставляет младшие 8 битов как есть.

Вы также можете написать это; все они эквивалентны: int pos = ((int) b) & 0xFF; // сначала конвертируем b в int, затем отбрасываем старшие биты int pos = b & 0xFF; // сделано как арифметика int - приведение не требуется

Java автоматически «продвигает» целочисленные типы, размер которых (в # битах) меньше, чем int, к значению int при выполнении арифметики. Это сделано для обеспечения более детерминированного результата (чем, скажем, C, который менее ограничен в своей спецификации).

Возможно, вы захотите взглянуть на на этот вопрос, когда ставите «шорт».