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

Примитивные типы в куче (Heap)

Краткий ответ: Примитивные типы НЕ хранятся в куче, они хранятся в стеке (Stack). Однако обёрнутые версии примитивов (Integer, Double и т.д.) хранятся в куче.

Размещение в памяти

public class MemoryPlacement {
    public static void main(String[] args) {
        // ПРИМИТИВЫ → СТЕК (Stack)
        int age = 25;               // Stack
        double salary = 50000.00;   // Stack
        boolean isActive = true;    // Stack
        
        // ОБЁРНУТЫЕ ТИПЫ → КУЧА (Heap)
        Integer ageObj = 25;        // Heap (Объект Integer)
        Double salaryObj = 50000.0; // Heap (Объект Double)
        Boolean isActiveObj = true; // Heap (Объект Boolean)
        
        // СТРОКИ → КУЧА (Heap)
        String name = "John";       // Heap (Объект String)
    }
}

// Визуально:
//
// STACK (память вызовов)
// ┌─────────────────────┐
// │ age = 25 (int)      │
// │ salary = 50000      │
// │ isActive = true     │
// │ ageObj → [ref]  ────┼──┐
// │ salaryObj → [ref]──┼──┤
// │ isActiveObj → [ref]┼──┤
// │ name → [ref] ──────┼──┤
// └─────────────────────┘  │
//                          │
// HEAP (динамическая память)
// ┌──────────────────────────┐
// │ [ref] → Integer(25)      │ ← ageObj
// │ [ref] → Double(50000.0)  │ ← salaryObj
// │ [ref] → Boolean(true)    │ ← isActiveObj
// │ [ref] → String("John")   │ ← name
// └──────────────────────────┘

Детальное объяснение

public class DetailedExample {
    
    // Метод 1: только примитивы
    public void primitiveOnly() {
        int a = 10;      // Stack: a = 10
        int b = 20;      // Stack: b = 20
        int c = a + b;   // Stack: c = 30
        
        // После return все переменные удаляются со стека
    }
    
    // Метод 2: примитивы + обёрнутые типы
    public void mixedTypes() {
        int primitive = 42;           // Stack
        Integer wrapped = 42;         // Stack содержит ссылку на объект Integer в Heap
        Integer another = new Integer(42);
        
        // ВАЖНО: primitive и wrapped — это РАЗНЫЕ области памяти
        // primitive в Stack
        // wrapped в Heap
    }
    
    // Метод 3: коллекции (всегда в Heap)
    public void collections() {
        List<Integer> numbers = new ArrayList<>();  // List в Heap, Integer в Heap
        numbers.add(1);    // Autoboxing: 1 → Integer, хранится в Heap
        numbers.add(2);    // Autoboxing
        numbers.add(3);    // Autoboxing
        
        // После return все объекты в Heap станут доступны для GC
    }
}

Цикл жизни памяти

public class MemoryLifecycle {
    public static void main(String[] args) {
        // 1. Stack: объявляем примитив
        int age = 25;  // Stack: age = 25
        
        // 2. Heap: создаём объект
        Person person = new Person("John", 25);  // Heap: новый объект Person
        
        // 3. Stack: ссылка на объект
        // Stack: person → [ссылка на объект в Heap]
        
        if (true) {
            int localAge = 30;  // Stack: localAge = 30
        }  // localAge удаляется из Stack здесь
        
        System.out.println(age);  // 25, всё ещё в Stack
        
    }  // main заканчивается
    // age удаляется из Stack
    // person удаляется из Stack
    // объект Person остаётся в Heap (если на него нет других ссылок)
    // GC (Garbage Collector) удаляет неиспользуемый объект
}

class Person {
    String name;  // Объект в Heap
    int age;      // Примитив в объекте (в Heap вместе с объектом)
    
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Stack vs Heap сравнение

Примеры переполнения

public class StackOverflow {
    // ❌ Бесконечная рекурсия → StackOverflowError
    public void recursiveMethod() {
        int local = 1;  // Stack: 4 байта для каждого вызова
        recursiveMethod();  // Stack: ещё 4 байта
        // → 1000+ вызовов исчерпают Stack
    }
}

public class HeapOverflow {
    // ❌ Много объектов → OutOfMemoryError
    public void allocateMemory() {
        List<byte[]> list = new ArrayList<>();
        while (true) {
            list.add(new byte[1024 * 1024]);  // 1MB каждый → Heap переполнится
        }
    }
}

Практические следствия

public class PracticalImpacts {
    
    // ✓ Эффективно: примитивы в коллекциях
    public void primitiveArray() {
        int[] array = new int[1000000];  // Stack: ссылка, Heap: 4MB примитивов
    }
    
    // ❌ Неэффективно: обёрнутые типы вместо примитивов
    public void wrappedArray() {
        Integer[] array = new Integer[1000000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;  // Каждый Integer → отдельный объект в Heap!
        }
        // Много overhead из-за автоboxing
    }
    
    // Рекомендация: используй примитивные типы для массивов
    // для экономии памяти и производительности
}

Где примитивы в сложных структурах

public class ComplexStructure {
    
    @Entity
    public class User {
        @Id
        private int userId;        // Примитив внутри объекта → Heap
        private String name;       // Объект → Heap
        private double salary;     // Примитив → Heap (вместе с объектом)
    }
    
    // Размещение:
    // Heap: [User object]
    //   ├─ userId: 4 bytes (примитив в объекте)
    //   ├─ name: reference → String object → "John"
    //   └─ salary: 8 bytes (примитив в объекте)
}

Вывод: Примитивные типы хранятся в Stack и удаляются автоматически при выходе из области. Обёрнутые типы и объекты хранятся в Heap и удаляются Garbage Collector'ом.