Как компиляторы Java работают с примитивными типами на уровне байт-кода

Примитивные типы Java на уровне байт-кода

Это глубокий вопрос о том, как Java компилятор преобразует исходный код в байт-код и как примитивные типы обрабатываются на этом уровне.

Примитивные типы в Java

// В Kotlin/Java есть 8 примитивных типов
boolean  // 1 бит (в памяти обычно 1 байт)
byte     // 8 бит (-128 до 127)
short    // 16 бит (-32768 до 32767)
char     // 16 бит (0 до 65535)
int      // 32 бита
long     // 64 бита
float    // 32 бита (IEEE 754)
double   // 64 бита (IEEE 754)

Как компилятор преобразует примитивы

Процесс компиляции Java:

Java Source Code (.java)
    ↓ (javac compile)
ByteCode (.class файл в Java bytecode)
    ↓ (JIT compile в runtime)
Native Machine Code
    ↓ (JVM execution)
Экзекьюция на CPU

Пример: преобразование простого кода

// Java/Kotlin исходный код
fun calculateSum(): Int {
    val a = 10
    val b = 20
    return a + b
}

Эквивалент в Java bytecode:

// Bytecode (упрощенно)
const_10      // Загрузить константу 10 на стек
store_1       // Сохранить в переменную a (индекс 1)
const_20      // Загрузить константу 20 на стек
store_2       // Сохранить в переменную b (индекс 2)
load_1        // Загрузить a со стека
load_2        // Загрузить b со стека
iadd          // Сложить два int'а
return        // Вернуть результат

JVM Stack и примитивные типы

JVM использует stack для локальных переменных:

fun example() {
    val intVar: Int = 42
    val longVar: Long = 1000L
    val boolVar: Boolean = true
    val doubleVar: Double = 3.14
}

// Bytecode layout (Local Variables Array)
// Index 0: this (если метод в классе)
// Index 1: intVar (4 байта)
// Index 2: longVar (8 байт, занимает index 2 и 3!)
// Index 4: boolVar (4 байта, хранится как int: 0 или 1)
// Index 5: doubleVar (8 байт, занимает index 5 и 6!)

Инструкции bytecode для примитивов

Для каждого типа есть свои инструкции:

// INT операции
iadd, isub, imul, idiv, irem  // Арифметика
iload, istore                   // Load/store
iinc                           // Инкремент

// LONG операции  
ladd, lsub, lmul, ldiv, lrem
lload, lstore

// FLOAT операции
fadd, fsub, fmul, fdiv, frem
fload, fstore

// DOUBLE операции
dadd, dsub, dmul, ddiv, drem
dload, dstore

// BOOLEAN / BYTE операции (используют int инструкции)
iadd, isub, imul  // Boolean хранится как int 0/1

Boxing/Unboxing на bytecode уровне

Когда примитив оборачивается в объект:

// Kotlin код с boxing
val intValue: Int = 42
val boxedValue: Integer = intValue  // Boxing
val unboxedValue: Int = boxedValue  // Unboxing

Bytecode:

// Оригинальный код
push 42
store_1 (intValue)

// Boxing: вызов Integer.valueOf()
load_1
invokestatic Integer/valueOf(I)Ljava/lang/Integer;  // Вызов valueOf
store_2 (boxedValue)

// Unboxing: вызов intValue()
load_2
invokevirtual Integer/intValue()I  // Вызов intValue
store_3 (unboxedValue)

Автоматический Boxing/Unboxing

Компилятор делает это автоматически:

fun example() {
    val list = mutableListOf<Integer>()
    list.add(42)  // Auto-boxing: Integer.valueOf(42)
    
    val value: Int = list[0]  // Auto-unboxing: list[0].intValue()
}

Type Casting на bytecode уровне

val doubleVal: Double = 3.14
val intVal: Int = doubleVal.toInt()  // Конверсия типов

Bytecode:

dload_1         // Загрузить double
d2i             // Double to Int конверсия
istore_3        // Сохранить int

Массивы примитивов

val intArray = IntArray(10)
intArray[0] = 42
val value = intArray[5]

Bytecode:

const_10
newarray int      // Создать массив int размером 10
astore_1          // Сохранить ссылку на массив

aload_1           // Загрузить ссылку на массив
const_0           // Индекс 0
const_42          // Значение
iastore           // Сохранить int в массив[0]

aload_1           // Загрузить ссылку на массив
const_5           // Индекс 5
iaload            // Загрузить int из массива[5]
istore_3          // Сохранить в переменную

Оптимизации JIT компилятора

JIT (Just-In-Time) компилятор делает дополнительные оптимизации:

// Java bytecode
for (i in 0..1000) {
    val result = i + 10
}

// JIT может оптимизировать:
// 1. Loop unrolling: развернуть цикл
// 2. Dead code elimination: убрать неиспользованные вычисления
// 3. Escape analysis: если result не используется, может убрать вычисление
// 4. Inline: встроить простые операции

Примеры оптимизаций

1. Constant Folding

val result = 10 + 20  // Компилятор вычисляет как 30 на compile-time

// Bytecode
push 30  // Прямо 30, не 10+20!

2. Dead Code Elimination

val x = 10
val y = 20  // Если y не используется
return x    // y может быть полностью удален

3. Inlining

inline fun add(a: Int, b: Int): Int = a + b

val result = add(10, 20)

// Becomes:
val result = 10 + 20  // Функция встроена, вызова нет

Memory Layout примитивов

В Java объектах примитивы хранятся напрямую (не как ссылки):

data class Point(
    val x: Int,    // 4 байта
    val y: Int     // 4 байта
)

// Memory: |object_header|x(4)|y(4)| = ~16 байт на 64-bit JVM

// Сравни с wrapper classes:
val point = object {
    val x = Integer(10)  // Объект: header + 4 байта
    val y = Integer(20)  // Объект: header + 4 байта
}  // ~32-40 байт!

JVM Instructions для примитивов

Примитивные операции очень эффективны:
- Арифметика: 1-2 CPU цикла
- Load/store: 1-2 CPU цикла
- Array access: 2-3 CPU цикла

Оборачивание в объект дорого:
- Boxing: ~10-50 CPU циклов
- Garbage collection overhead

Вывод

Примитивные типы на bytecode уровне:

1. Имеют специальные инструкции (iadd, dadd и т.д.)
2. Хранятся на stack'е (не в heap)
3. Быстро обрабатываются (native CPU инструкции)
4. Boxing конвертирует в объекты (Wrapper classes)
5. JIT оптимизирует дополнительно в runtime
6. Максимально эффективны для численных вычислений

Это почему примитивные типы значительно быстрее обычных объектов в Java/Kotlin.