Как работает в Java? [Дубликат]

Концептуально повторяющиеся вычитания 256 выполняются на ваш номер, пока он не будет в диапазоне от -128 до +127. Итак, в вашем случае вы начинаете с 132, а затем заканчиваете на -124 за один шаг.

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

Обратите внимание, что на других языках это поведение не определено (например, C и C ++).

байт в Java подписан, поэтому он имеет диапазон от -2 ^ 7 до 2 ^ 7-1, т. е. от -128 до 127. Поскольку 132 превышает 127, вы обертываете вокруг 132-256 = -124 , То есть, по существу, 256 (2 ^ 8) добавляется или вычитается до тех пор, пока он не попадет в диапазон.

Для получения дополнительной информации вы можете прочитать два дополнения .

 N is input number
case 1: 0<=N<=127  answer=N;
case 2: 128<=N<=256 answer=N-256 
case 3: N>256   
        temp1=N/256;
        temp2=N-temp*256;
        if temp2<=127   then answer=temp2;
        else if temp2>=128  then answer=temp2-256;
case 4: negative  number input
        do same procedure.just change the sign of the solution           

Быстрый алгоритм, который имитирует способ его работы, следующий:

public int toByte(int number) {
    int tmp = number & 0xff
    return (tmp & 0x80) == 0 ? tmp : tmp - 256;
}

Как это работает? Посмотрите на daixtr ответ. Реализация точного алгоритма, описанная в его ответе, такова:

public static int toByte(int number) {
    int tmp = number & 0xff;
    if ((tmp & 0x80) == 0x80) {
        int bit = 1;
        int mask = 0;
        for(;;) {
            mask |= bit;
            if ((tmp & bit) == 0) {
                bit <<=1;
                continue;
            }
            int left = tmp & (~mask);
            int right = tmp & mask;
            left = ~left;
            left &= (~mask);
            tmp = left | right;
            tmp = -(tmp & 0xff);
            break;
        }
    }
    return tmp;
}

здесь очень механический метод без отвлекающих теорий:

1. Преобразовать число в двоичное представление (использовать калькулятор в порядке?)
2. Копировать только самые правые 8 бит (LSB) и отбросить остальные.
3. Из результата шага №2, если крайний левый бит равен 0, используйте калькулятор для преобразования числа в десятичное. Это ваш ответ.
4. Else (если крайний левый бит равен 1), ваш ответ отрицательный. Оставьте все самые правые нули и первый ненулевой бит без изменений. И отменили остальные, т. Е. Заменили 1 на 0 и 0 на 1. Затем используйте калькулятор для преобразования в десятичную и добавьте отрицательный знак, чтобы указать отрицательное значение.

Этот более практичный метод соответствует многим теоретическим ответам выше. Итак, те, кто все еще читают эти Java-книги, говорящие, что используют modulo, это определенно неправильно, поскольку 4 шага, которые я изложил выше, определенно не являются модульной операцией.

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

public class castingsample{

public static void main(String args[]){

    int i;
    byte y;
    i = 1024;
    for(i = 1024; i > 0; i-- ){

      y = (byte)i;
      System.out.print(i + " mod 128 = " + i%128 + " also ");
      System.out.println(i + " cast to byte " + " = " + y);

    }

}

}

Чтобы понять, как это работает, нам нужно знать, что компьютеры работают в битах.

132 в base 10 (десятичный) является 10000100 в базе 2 (двоичный). Поскольку Java хранит int в 32 битах, мы имеем

00000000_00000000_00000000_10000100

Когда int преобразуется в byte, Java прерывает левый почти 24 бит. Мы получаем 10000100.

В дополнение двух в качестве знака используется самый левый бит. Если самый левый бит 0, ничего больше не будет сделано.

Если самый левый бит - 1 (как здесь, здесь), это означает, что число отрицательно и требуется больше работы. Чтобы получить величину, мы минус один, затем применим одно дополнение (применяем одно дополнение, чтобы инвертировать биты):

1. 10000100 - 1 = 10000011
2. Инверсия 10000011 = 01111100

01111100 при интерпретации десятичного числа равна 124.

Итак, мы имеем отрицательный число с величиной 124, что дает нам -124.

132 находится вне диапазона байта, который составляет от -128 до 127 (Byte.MIN_VALUE - Byte.MAX_VALUE). Вместо этого верхний бит 8-битного значения обрабатывается как подписанный, который указывает, что в этом случае он отрицательный. Таким образом, число равно 132 - 256 = -124.

Дополнение к двум уравнениям:

В Java, byte (N = 8) и int (N = 32) представлены приведенным выше 2s-дополнением.

Из уравнения a7 отрицательно для byte, но положительно для int.

coef:   a7    a6  a5  a4  a3  a2  a1  a0
Binary: 1     0   0   0   0   1   0   0
----------------------------------------------
int:    128 + 0 + 0 + 0 + 0 + 4 + 0 + 0 =  132
byte:  -128 + 0 + 0 + 0 + 0 + 4 + 0 + 0 = -124