Какой диапазон значений может включать byte?

Диапазон значений byte в Java: -128 до 127

byte — это один из примитивных типов данных в Java. Это целое число со знаком, занимающее 8 бит в памяти. Диапазон значений, которые может включать byte: от -128 до 127 включительно, всего 256 различных значений (2^8).

Почему именно этот диапазон

Диапазон определяется двоичным представлением 8-битного целого числа со знаком (signed):

• Старший бит (leftmost) — знаковый бит (sign bit): 0 = положительное, 1 = отрицательное
• Оставшиеся 7 бит — значение числа

Минимальное значение (все биты = 1): 10000000 = -128
Максимальное значение (7 бит = 1):   01111111 = 127
Ноль:                                  00000000 = 0

Примеры использования

// Явное объявление byte переменных
byte minValue = -128;      // Минимум
byte maxValue = 127;       // Максимум
byte zero = 0;
byte negative = -50;
byte positive = 100;

// Литеральное присваивание
byte b1 = 100;             // OK, в диапазоне
byte b2 = 200;             // ОШИБКА: слишком большое значение

// Приведение типа (casting)
int largeValue = 200;
byte b3 = (byte) largeValue;  // OK, но произойдёт переполнение
// 200 в бинарном: 11001000 → интерпретируется как -56 (two's complement)

Границы byte значений

public class ByteRanges {
    public static void main(String[] args) {
        // Константы для минимальных и максимальных значений
        System.out.println("Minimum byte: " + Byte.MIN_VALUE);  // -128
        System.out.println("Maximum byte: " + Byte.MAX_VALUE);  // 127
        System.out.println("Size in bits: " + Byte.SIZE);       // 8
        
        // Демонстрация переполнения
        byte max = Byte.MAX_VALUE;
        System.out.println("max + 1 = " + (byte)(max + 1));     // -128 (переполнение)
        
        byte min = Byte.MIN_VALUE;
        System.out.println("min - 1 = " + (byte)(min - 1));     // 127 (переполнение)
    }
}

Переполнение (Overflow) в Java

Когда значение выходит за границы диапазона, происходит переполнение (overflow):

byte value = 127;      // Максимум
byte overflowed = (byte)(value + 1);  // = -128 (обёрнулось)

// Это называется two's complement переполнение
// Java не выбрасывает исключение, а просто обёртывает значение

byte negValue = -128;   // Минимум
byte underflowed = (byte)(negValue - 1);  // = 127 (обёрнулось)

Практическое применение byte

Использование byte полезно для:

// 1. Работа с потоками и файлами
InputStream input = new FileInputStream("data.bin");
byte[] buffer = new byte[1024];      // Буфер из 1024 байт
int bytesRead = input.read(buffer);

// 2. Работа с сетевыми протоколами
public class PacketHeader {
    byte version;          // версия протокола (0-127)
    byte type;            // тип пакета
    byte flags;           // флаги
}

// 3. Сжатие памяти когда значения гарантированно малые
class SmallNumbers {
    byte[] ages = new byte[1000];     // возраст: 0-127 лет
    // вместо int[] который занял бы 4000 байт, используем 1000 байт
}

// 4. Криптография и хеширование
import java.security.MessageDigest;
MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] hash = md.digest(data);     // каждый элемент 0-255 (unsigned)

Важное различие: Signed vs Unsigned

byte в Java — всегда SIGNED (со знаком):

// Если нужны unsigned значения (0-255), используй:
short unsignedByte = 255;           // или
int unsignedByte = Byte.toUnsignedInt((byte) 255);  // = 255

// В массивах часто интерпретируют как unsigned:
byte[] data = {(byte)255, (byte)128, (byte)0};
for (byte b : data) {
    int unsigned = b & 0xFF;       // маска для получения 0-255
    System.out.println(unsigned);  // 255, 128, 0
}

Сравнение с другими типами

Заключение

byte в Java может содержать значения от -128 до 127 включительно. Это знаковый 8-битный целый тип. Использование byte полезно для экономии памяти при работе с потоками данных, файлами и сетью, где каждый байт критичен. При переполнении значение автоматически обёртывается (wraps around) в диапазоне без выброса исключения.