Heap vs Stack

TL;DR

• Heap: A massive, shared memory space where all Objects (e.g., new Student()) and their instance variables live. It is managed by the Garbage Collector.
• Stack: A small, fast, thread-specific memory space where method executions and local primitive variables live. It is strictly LIFO (Last-In-First-Out).

Concept

The Heap and Stack work together constantly.

When you write Student s = new Student(); inside a method:

1. new Student() allocates a large block of memory on the Heap to hold the object’s data (like its name and age).
2. Student s creates a tiny reference variable on the current thread’s Stack.
3. The reference variable s stores the memory address pointing to the massive object on the Heap.

Lifecycle Differences

• Stack Memory is extremely short-lived. When a method finishes executing, its Stack Frame is instantly popped off the top of the stack and destroyed. Memory is reclaimed instantaneously.
• Heap Memory is long-lived. When a method finishes, the reference variable on the Stack is destroyed, but the actual Object on the Heap remains. It will sit there consuming RAM until the Garbage Collector eventually wakes up, realizes no one is pointing to the object anymore, and deletes it.

Examples

public class HeapVsStack {
    
    public static void main(String[] args) {
        // 'age' is a primitive local variable. It lives entirely on the STACK.
        int age = 30; 
        
        // 'user' is a local reference variable on the STACK.
        // 'new User()' is the actual object created on the HEAP.
        User user = new User("Alice"); 
        
        // Calls a new method. A new Frame is pushed onto the STACK.
        processUser(user); 
        
        // When processUser finishes, its Stack Frame is destroyed.
    }
    
    public static void processUser(User u) {
        // 'u' is a new reference variable on the STACK, but it points to the 
        // EXACT SAME Object on the HEAP as the 'user' variable in main.
        
        // 'multiplier' is a primitive local variable on the STACK.
        double multiplier = 1.5; 
    }
}

Interview Questions

Q: Why is primitive wrapper classes (like Integer) slower than primitive types (like int)?
A: An int is a primitive. It is stored directly on the fast Stack memory. An Integer is a full Java Object. Creating an Integer requires allocating memory on the slower Heap, creating a reference on the Stack to point to it, and eventually requires the Garbage Collector to clean it up. Therefore, heavy math calculations using Integer wrappers are significantly slower and consume far more memory.

Q: Can an Object ever be stored on the Stack?
A: In traditional Java, No. Objects are always stored on the Heap. However, modern JVMs utilize a severe optimization technique called Escape Analysis. If the JIT compiler detects that a newly created object is used entirely within a single method and is never returned or passed to another thread (meaning it never “escapes” the method), the JVM may optimize performance by breaking the object down and allocating its fields directly onto the Stack, completely bypassing Heap allocation and Garbage Collection.