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

Ответ 1

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

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

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

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

Ответ 2

int i = 255;

byte b = (byte)i;

Итак, значение be in hex равно 0xFF, но десятичное значение будет равно -1.

int i = 0xff00;

byte b = (byte)i;

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

Ответ 3

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

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

Ответ 4

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

например.

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

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

Ответ 5

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 при выполнении арифметики. Это делается для обеспечения более детерминированного результата (чем C, который менее ограничен в своей спецификации).

Возможно, вам стоит взглянуть на на этот вопрос по поводу "короткого" .

Ответ 6

Это моя версия литья любого возможного объекта в Byte

private Byte castToByte(Object value, Byte def)
{
    if (value instanceof Integer)
    {
        return ((Integer) value).byteValue();
    }
    else if (value instanceof Number)
    {
        return ((Number) value).byteValue();
    }
    else if (value instanceof String)
    {
        return Byte.valueOf((String) value);
    }
    return def;
}

Ответ 7

По моему мнению, вы имели в виду

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

Ответ 8

Байт 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