Может ли примитивный тип данных попасть в heap?

# Примитивные типы в Heap vs Stack в Java

Краткий ответ

Да, примитивные типы могут попасть в heap. Это происходит в двух случаях:

1. Когда примитив упакован в Object (autoboxing)
2. Когда примитив находится внутри объекта как поле

Stack vs Heap в Java

Stack (стек)

Хранит:

• Примитивные типы (int, long, double, boolean, char, byte, short, float)
• Ссылки на объекты
• Вызовы методов

Характеристики:

• Очень быстрый доступ
• Автоматическая очистка (LIFO)
• Ограниченный размер
• Каждый поток имеет свой stack

public void demo() {
    int x = 5;        // Stack: примитив 5
    double y = 10.5;  // Stack: примитив 10.5
    String name = "John"; // Stack: ссылка на объект
    // Объект "John" находится в Heap
}
// После выхода из метода x, y, name удаляются из Stack

Heap (куча)

Хранит:

• Все объекты (Object, String, Array, List, и т.д.)
• Упакованные примитивы (Integer, Long, Double, Boolean и т.д.)

Характеристики:

• Медленнее, чем Stack
• Очищается Garbage Collector
• Общий для всех потоков
• Гораздо больший размер

public void demo() {
    Integer x = 5;  // Heap: объект Integer с значением 5
                    // Stack: ссылка на этот объект
}
// x удаляется из Stack сразу
// Объект Integer в Heap удаляется GC позже

Случай 1: Autoboxing (упаковка примитива)

Джава автоматически преобразует примитив в объект:

// Примитив - Stack
int x = 5;

// Упакованный примитив - Heap (объект Integer)
Integer boxedX = x;  // Autoboxing: int -> Integer (объект в Heap)
Integer y = Integer.valueOf(10);  // Явная упаковка -> Heap

// Разупаковка - извлечение примитива из объекта
int unboxed = boxedX;  // Unboxing: Integer -> int (из Heap в Stack)

Когда происходит autoboxing

// 1. Присваивание
Integer x = 5;  // Autoboxing

// 2. Методы, ожидающие объекта
List<Integer> numbers = new ArrayList<>();
numbers.add(10);  // Autoboxing: int -> Integer

// 3. Параметры метода
public void printNumber(Integer num) {}
printNumber(5);  // Autoboxing

// 4. Условные выражения
Integer result = (x > 10) ? 100 : 200;  // Autoboxing результата

Случай 2: Примитив как поле объекта

Примитив находится внутри объекта, который живёт в Heap:

public class User {
    private int age;  // Примитив, но находится внутри объекта
    private String name;  // Ссылка на объект String
    private Integer score;  // Упакованный примитив
}

// Создание объекта
User user = new User();  // Объект User в Heap
// Поле age (примитив) находится в памяти объекта в Heap
// Поле name (ссылка) указывает на String в Heap
// Поле score (Integer) указывает на объект Integer в Heap

Примитивы в массивах

// Массив примитивов
int[] numbers = {1, 2, 3};  // Массив в Heap, элементы тоже в Heap
                             // (они часть объекта массива)

// Массив объектов
Integer[] boxedNumbers = {1, 2, 3};  // Массив в Heap
                                      // Содержит ссылки на Integer объекты в Heap

// Список с autoboxing
List<Integer> list = new ArrayList<>();
list.add(5);  // Элементы Integer объекты в Heap

Производительность: примитив vs упакованный

// БЫСТРО - примитивы в Stack
for (int i = 0; i < 1_000_000; i++) {
    int x = i * 2;  // Stack операции
}

// МЕДЛЕННЕЕ - упакованные примитивы
for (int i = 0; i < 1_000_000; i++) {
    Integer x = i * 2;  // Heap операции + autoboxing
}

// НАМНОГО МЕДЛЕННЕЕ - List с упакованными
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    list.add(i);  // Autoboxing + resize + allocation
}

Nullable примитивы

Одна из причин использовать упакованные примитивы — возможность быть null:

// ❌ Примитив не может быть null
int age = null;  // Compile error

// ✓ Упакованный примитив может быть null
Integer age = null;  // OK

// Пример использования
public Integer calculateAge(String birthDate) {
    if (birthDate == null) {
        return null;  // Отсутствие значения
    }
    return calculateAgeFromDate(birthDate);
}

// В БД
@Column(name = "age")
private Integer age;  // Может быть NULL в БД

// В REST API
@GetMapping("/{id}")
public User getUser(@PathVariable Integer id) {
    // id может быть null если путь некорректен
}

Память: сколько занимает

// Примитивы в Stack (занимают место на Stack)
int x = 5;          // 4 байта на Stack
long y = 100L;      // 8 байт на Stack
boolean z = true;   // 1 байт на Stack

// Упакованные примитивы в Heap
Integer boxedX = 5;  // 16 байт (overhead) + 4 байта = 20 байт в Heap
Long boxedY = 100L;  // 16 байт (overhead) + 8 байт = 24 байта в Heap

// Объект с примитивом в Heap
public class Data {
    private int value;  // 4 байта внутри объекта
}
Data data = new Data();  // 16 байт (overhead) + 4 байта value = 20 байт

Когда использовать какой тип

Используй примитивы (Stack)

public class Calculator {
    public int add(int a, int b) {
        return a + b;  // Примитивы - быстро
    }
    
    private int value;  // Примитив как поле - компактно
}

Когда:

• Значение всегда есть (не может быть null)
• Нужна максимальная производительность
• Работаешь с простыми локальными переменными

Используй упакованные примитивы (Heap)

public class User {
    @Column(name = "age")
    private Integer age;  // Может быть NULL в БД
}

List<Integer> scores = new ArrayList<>();  // Generic требует Object

public Optional<Integer> findAge(String name) {
    // Может вернуть empty() вместо null
}

Когда:

• Значение может быть null (опциональное)
• Используешь Generic (List<Integer>, Map<String, Double>)
• Нужна гибкость API (возвращать null или Optional)
• Работаешь с БД (NULL в колонке)

Заключение

Да, примитивные типы могут попасть в Heap через:

1. Autoboxing — Integer x = 5 создаёт объект в Heap
2. Поля объектов — примитив в объекте находится в памяти объекта в Heap
3. Массивы объектов — Integer[] содержит ссылки на объекты в Heap

Жди:

• Примитивы в Stack быстрее
• Упакованные примитивы нужны для nullable значений и Generic
• Используй примитивы для простых значений, объекты для сложности