Сколько байт занимает байт?

Сколько байт занимает байт?

Это хитрый вопрос, который проверяет понимание разницы между логическим размером типа данных и его реальным размером в памяти.

Простой ответ

На логическом уровне: byte в Java занимает 1 байт (8 бит)

Но на уровне JVM и памяти ответ сложнее.

Логический размер типа byte

public class ByteSize {
    public static void main(String[] args) {
        System.out.println("Byte.SIZE: " + Byte.SIZE);           // 8 бит
        System.out.println("Byte.BYTES: " + Byte.BYTES);         // 1 байт
    }
}

// Вывод:
// Byte.SIZE: 8
// Byte.BYTES: 1

Диапазон значений byte:

1 байт = 8 бит

Диапазон: -128 до 127 (256 значений)

Вычисление:
С одним битом для знака: 2^7 = 128 значений для отрицательных
                         2^7 = 128 значений для положительных (0-127)
Всего: 256 значений

Но это еще не все...

В памяти объект byte занимает больше, чем 1 байт!

public class ByteMemoryTest {
    // Примитивный тип в переменной
    private byte primitiveValue = 10;  // Занимает 1 байт в стеке
    
    // Объект типа Byte
    private Byte objectValue = 10;     // Занимает ~ 16 байт в heap!
}

Размер Byte объекта в памяти

Byte как объект занимает:

объект Byte:
├─ Object header: 12-16 байт (зависит от JVM)
│  ├─ Class pointer: 8 байт
│  └─ Mark word: 8 байт
│  └─ Padding: 0-8 байт
└─ Данные: 1 байт

Итого: ~16 байт (на 64-bit JVM)

Детальный анализ:

import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.vm.VM;

public class ByteObjectSize {
    public static void main(String[] args) {
        System.out.println(VM.current().details());
        
        Byte b = 10;
        System.out.println(ClassLayout.parseInstance(b).toPrintable());
    }
}

// Вывод может быть:
// 00000000 (offset=0, size=8):  Mark Word
// 00000008 (offset=8, size=8):  Class Pointer
// 00000010 (offset=16, size=1): byte value = 10
// 00000011 (offset=17, size=7): Padding
//
// Total size: 24 bytes! (в некоторых JVM может быть 16)

Почему такой overhead?

JVM нужна дополнительная информация для каждого объекта:

1. Class pointer (8 байт) — информация о типе объекта

   • Позволяет JVM узнать, что это Byte
   • Нужна для instanceof, getClass(), и.т.д

2. Mark word (8 байт) — состояние объекта

   • Блокировка (для synchronized)
   • Хеш-код
   • GC информация

3. Padding (0-8 байт) — выравнивание в памяти

   • Все объекты должны быть кратны 8 байтам
   • Улучшает производительность доступа к памяти

Сравнение: примитив vs объект

public class PrimitiveVsObject {
    // Примитив в переменной (в стеке)
    byte primitiveByte = 10;        // 1 байт в стеке
    
    // Объект (в heap)
    Byte objectByte = 10;           // 16-24 байт в heap
                                     // + 8 байт reference в стеке
    
    // Массив примитивов (эффективно)
    byte[] byteArray = new byte[1000];  // 1000 байт (+ 16 байт overhead)
    
    // Массив объектов (неэффективно)
    Byte[] objectArray = new Byte[1000]; // ~16k байт (16-24 за объект)
}

// Анализ памяти:
Byte b = new Byte(10);
  Объект: 16-24 байта в heap
  Reference: 8 байт в стеке/объекте
  ИТОГО: 24-32 байта

byte b = 10;
  Примитив: 1 байт в стеке
  ИТОГО: 1 байт

// Разница: в 24-32 раза!

Автоупаковка (autoboxing) — скрытый враг

public class AutoboxingMemory {
    public static void main(String[] args) {
        // Это может быть менее эффективно, чем кажется
        
        List<Byte> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add((byte)i);  // Каждый add создаёт новый Byte объект!
        }
        // Память: 1000 * 16 байт = 16KB на Byte объекты
        // Плюс: List overhead, references
        // ИТОГО: ~32KB для хранения 1000 байт данных
    }
}

// Было бы лучше:
byte[] array = new byte[1000];
// Память: 1000 байт (+ 16 байт overhead) = ~1KB

Integer Cache — оптимизация JVM

Java кеширует целые объекты для экономии памяти:

public class IntegerCacheTest {
    public static void main(String[] args) {
        // Byte кеширует ВСЕ значения (-128 до 127)
        Byte b1 = 10;
        Byte b2 = 10;
        System.out.println(b1 == b2);  // true! (один объект)
        System.out.println(b1 == new Byte(10));  // false (новый объект)
        
        // Integer кеширует значения (-128 до 127)
        Integer i1 = 100;
        Integer i2 = 100;
        System.out.println(i1 == i2);  // true (кеш)
        
        Integer i3 = 200;
        Integer i4 = 200;
        System.out.println(i3 == i4);  // false (новые объекты, нет кеша)
    }
}

// Кеш работает для byte:
// В Java есть ByteCache, который кеширует Byte(-128..127)
public class Byte {
    private static class ByteCache {
        static final Byte cache[] = new Byte[-(-128) + 127 + 1];
        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Byte((byte)(i - 128));
        }
    }
}

На практике: массивы

public class ArrayMemory {
    public static void main(String[] args) {
        // Массив примитивов
        byte[] byteArray = new byte[1000000];
        // Память: 1,000,000 байт + 16 байт (array overhead)
        // = ~1 MB
        
        // Массив объектов
        Byte[] objectArray = new Byte[1000000];
        // Память: 1,000,000 * 24 байт (если не кеш) + references
        // + 16 байт (array overhead)
        // = ~24 MB (в 24 раза больше!)
    }
}

Проверка размера с помощью инструментов

// Использование JOL (Java Object Layout)
import org.openjdk.jol.info.ClassLayout;

public class CheckByteSize {
    public static void main(String[] args) {
        System.out.println(ClassLayout.parseClass(Byte.class).toPrintable());
        
        Byte b = 10;
        System.out.println("\nInstance of Byte:");
        System.out.println(ClassLayout.parseInstance(b).toPrintable());
    }
}

// Вывод (64-bit JVM):
// com.example.Byte object internals:
//  OFFSET  SIZE      TYPE DESCRIPTION
//       0    12           (object header)
//      12     1    byte    value
//      13     3           (padding)
//  Instance size: 16 bytes

Ответ на вопрос: "Сколько байт занимает byte?"

Точный ответ зависит от контекста:

Ключевые выводы

• Логический размер byte: 1 байт
• Объект Byte в памяти: 16-24 байта (зависит от JVM и выравнивания)
• Примитив в переменной: 1 байт
• Используй примитивы, когда можно — они значительно экономнее
• Массивы примитивов vs объектов — разница в 20-30 раз
• Byte кеширует значения (-128 до 127), что экономит память
• Autoboxing может быть неэффективным — на миллионах объектов это критично

Этот вопрос проверяет глубокое понимание JVM и управления памятью — просто знать "1 байт" недостаточно!