Хранятся ли в стеке локальные переменные методов

Локальные переменные и память: Stack vs Heap

Да, локальные переменные методов хранятся в стеке (Stack). Это фундаментальный принцип управления памятью в Java, но с важными нюансами.

Где хранятся переменные?

1. Stack (Стек) — локальные переменные

• Примитивные типы (int, double, boolean и т.д.)
• Ссылки на объекты (само значение адреса)
• Локальные переменные методов
• Параметры методов

2. Heap (Куча) — сами объекты

• Все объекты (new String(), new ArrayList(), и т.д.)
• Массивы
• Экземпляры классов

Пример: что где хранится?

public void myMethod() {
    // STACK: переменные name, age, list (ссылки)
    // HEAP: объекты String, Integer, ArrayList
    
    int age = 25;                              // age хранится в Stack
    String name = new String("Alice");        // name (ссылка) в Stack, объект в Heap
    List<Integer> numbers = new ArrayList<>(); // numbers (ссылка) в Stack, объект List в Heap
    
    numbers.add(10);                          // 10 в Heap вместе с List
    numbers.add(20);
}

Визуализация:

STACK                           HEAP
┌─────────────────┐            ┌────────────────────────┐
│ age: 25         │            │ String "Alice"         │
│ name: 0x123 ──────────────→ │ (в памяти Heap)        │
│ numbers: 0x456 ──────────┐   │                        │
└─────────────────┘        │   ├────────────────────────┤
                           │   │ ArrayList {10, 20}     │
                           └──→│ (в памяти Heap)        │
                               └────────────────────────┘

Жизненный цикл локальных переменных

public void processUser() {
    // 1. ВХОД В МЕТОД: создаётся новый stack frame
    User user = new User("Alice");     // user ссылка добавляется в Stack
    // Объект User создаётся в Heap
    
    if (user.getAge() > 18) {
        // 2. ВХОД В БЛОК: переменная доступна
        String status = "Adult";       // status добавляется в Stack
        System.out.println(status);
    }
    // 3. ВЫХОД ИЗ БЛОКА: status удаляется со Stack
    
    // 4. ВЫХОД ИЗ МЕТОДА: user удаляется со Stack
    // Если на объект User больше нет ссылок → он может быть собран GC
}

Примитивы vs Объекты

public void compareStorage() {
    // ПРИМИТИВЫ - полностью в Stack
    int num = 42;              // 42 хранится в Stack
    double salary = 50000.50;  // 50000.50 хранится в Stack
    boolean isActive = true;   // true хранится в Stack
    
    // ОБЪЕКТЫ - ссылка в Stack, сам объект в Heap
    Integer boxedNum = 42;                   // Ссылка в Stack, объект в Heap
    String text = "Hello";                   // Ссылка в Stack, объект в Heap
    User user = new User("Bob", 30);         // Ссылка в Stack, объект User в Heap
    
    // МАССИВЫ - ссылка в Stack, элементы в Heap
    int[] arr = {1, 2, 3, 4, 5};            // Ссылка arr в Stack, элементы в Heap
}

Производительность: почему это важно?

public class PerformanceExample {
    
    // Вариант 1: много создаваемых объектов (медленнее)
    public void slowMethod() {
        for (int i = 0; i < 1000000; i++) {
            Integer num = new Integer(i);        // Постоянное выделение памяти в Heap
            String str = new String("value");    // Новый объект каждый раз
        }
        // После цикла: GC должен очистить всё это
    }
    
    // Вариант 2: примитивы и переиспользование (быстрее)
    public void fastMethod() {
        int num;           // Ссылка в Stack
        String str;        // Переиспользуется
        
        for (int i = 0; i < 1000000; i++) {
            num = i;       // Переиспользование переменной
            str = "value"; // Переиспользование
        }
    }
}

Stack: LIFO (Last In, First Out)

public void demonstrateStack() {
    methodA();
}

private void methodA() {
    int a = 1;      // PUSH a в Stack
    methodB();
    // POP a после возврата из methodB
}

private void methodB() {
    int b = 2;      // PUSH b в Stack
    methodC();
    // POP b после возврата из methodC
}

private void methodC() {
    int c = 3;      // PUSH c в Stack
    // Stack теперь: [a, b, c]
}
// Stack теперь: [a]
// Stack теперь: []

Размер Stack и потенциальные проблемы

// ОПАСНО: бесконечная рекурсия приводит к StackOverflowError
private int recursiveBad(int n) {
    int[] arr = new int[10000];  // Большой локальный массив
    return recursiveBad(n + 1);  // Рекурсия без выхода
}
// StackOverflowError: Stack переполнен!

// БЕЗОПАСНО: правильная рекурсия
private int recursiveGood(int n) {
    if (n <= 0) return 0;        // Базовый случай
    int result = n + recursiveGood(n - 1);
    return result;
}

Эффективное использование Stack

public class StackOptimization {
    
    // 1. Используй примитивы вместо Objects
    public long sumArrayGood(int[] arr) {
        long sum = 0;  // Примитив в Stack
        for (int num : arr) {
            sum += num;
        }
        return sum;
    }
    
    // 2. Минимизируй область видимости
    public void processData() {
        List<User> users = loadUsers();
        
        // Используй блоки для ограничения видимости
        {
            String temp = processUsers(users);  // temp удалится из Stack
            System.out.println(temp);
        }
        // temp больше не в Stack
    }
    
    // 3. Переиспользуй переменные
    public void reuseVariables() {
        String buffer;  // Одна переменная
        for (int i = 0; i < 100; i++) {
            buffer = "Item " + i;  // Переиспользование
            process(buffer);
        }
    }
}

Параметры методов

public void callMethod() {
    int value = 10;
    String name = "Alice";
    User user = new User();
    
    processData(value, name, user);  // Параметры добавляются в Stack вызываемого метода
}

private void processData(int val, String nm, User usr) {
    // STACK (в этом методе):
    // val: 10
    // nm: ссылка на "Alice"
    // usr: ссылка на объект User
    
    // Это НЕ копирование для объектов!
    // val и nm — копии примитива и ссылки соответственно
}

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

• Локальные переменные всегда в Stack
• Ссылки на объекты в Stack, сами объекты в Heap
• Примитивы полностью в Stack
• Stack имеет ограниченный размер → нужна осторожность с рекурсией
• Heap почти без ограничений → используется для больших данных
• Stack управляется автоматически → переменные удаляются при выходе из области
• Heap требует GC → сборка мусора удаляет неиспользуемые объекты

Понимание этого различия критично для написания эффективного Java кода.