Stack vs Heap

Stack Memory in Java

The stack is a region of memory used for static memory allocation. It stores:

• Local variables (primitives)
• Method call frames
• Reference variables (the references, NOT the objects)
• Partial results

Each thread has its own private stack. The stack follows LIFO (Last In, First Out) order.

public class StackDemo {
    public static void main(String[] args) {
        int x = 10;           // x lives on stack
        double y = 3.14;      // y lives on stack
        String name = "Java"; // reference on stack, object on heap
        
        calculate(x, y);      // new stack frame created
    }
    
    public static double calculate(int a, double b) {
        int result = a * 2;   // result lives on this stack frame
        return result + b;    // stack frame destroyed after return
    }
}

Key characteristics:

• Fast access
• Size limited (usually 512KB - 1MB)
• Automatically managed
• Thread-safe (each thread has its own)
• Stores only primitives and references

Heap Memory in Java

The heap is used for dynamic memory allocation. It stores:

• All objects created with new
• Arrays
• Instance variables (fields of objects)
• Static variables

The heap is shared among all threads in the JVM.

public class HeapDemo {
    static int count = 0;           // static variable on heap
    
    public static void main(String[] args) {
        // Objects on heap:
        Person p1 = new Person("Alice", 30);  // Person object on heap
        Person p2 = new Person("Bob", 25);    // Person object on heap
        int[] numbers = new int[10];           // array on heap
        
        // What's on stack:
        // - p1, p2 (references to heap objects)
        // - numbers (reference to array)
    }
}

class Person {
    String name;  // instance variable (on heap with the object)
    int age;      // instance variable (on heap with the object)
    
    Person(String name, int age) {
        this.name = name;  // String object on heap
        this.age = age;
    }
}

Key characteristics:

• Slower access than stack
• Size can be large (GB)
• Managed by Garbage Collector
• Shared among all threads
• Stores objects and their instance data

Stack Frames

Every time a method is called, a new stack frame is created and pushed onto the stack. The frame contains:

1. Local variables for the method
2. Parameters passed to the method
3. Return address
4. Operand stack

public class StackFrameDemo {
    public static void main(String[] args) {
        int result = factorial(5);
    }
    
    public static int factorial(int n) {
        if (n <= 1) return 1;    // Base case
        return n * factorial(n - 1);  // Recursive call
    }
}

// Stack frames during execution:
// |------------------|
// | factorial(1)     |  <- n=1, returns 1
// | factorial(2)     |  <- n=2
// | factorial(3)     |  <- n=3
// | factorial(4)     |  <- n=4
// | factorial(5)     |  <- n=5
// | main()           |  <- args
// |------------------|
// Stack grows downward

Each frame has its own copy of local variables. When a method returns, its frame is popped from the stack.

Memory Diagram Examples

Understanding how memory is organized helps debug many Java issues.

Example 1: Object References

public class MemoryDiagramExample {
    public static void main(String[] args) {
        Point p1 = new Point(1, 2);
        Point p2 = p1;  // Both point to same object!
        
        p2.x = 100;  // This changes p1.x too!
        System.out.println(p1.x);  // 100, not 1
        
        p1 = new Point(5, 6);  // p1 now points to new object
        System.out.println(p2.x);  // Still 100
    }
}

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }
}

// Stack          Heap
// p1  ──────────> Point(1, 2)  <- shared!
// p2  ──────────/

Example 2: Array Memory

public class ArrayMemory {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = arr1;  // Same array!
        
        arr2[0] = 999;  // Changes arr1 too
        System.out.println(arr1[0]);  // 999
    }
}
// Stack          Heap
// arr1 ──────────> [999, 2, 3]
// arr2 ──────────/

Key takeaway: References are copied, not objects. Two references can point to the same object.

Interview Questions

Q: Where does a local variable of type String live?

A: The reference lives on the stack. The actual String object lives on the heap.

void example() {
    String s = "Hello";  // Reference 's' on stack
                          // "Hello" String object on heap
}

Q: Can you access stack memory from another thread?

A: No. Each thread has its own private stack. This makes stack variables thread-safe by default.

Q: What happens when stack memory is exhausted?

A: StackOverflowError is thrown. Common causes: infinite recursion or very deep recursion.

void infinite() {
    infinite();  // StackOverflowError!
}

Q: What is the difference between new String("hello") and "hello"?

A: new String("hello") creates a new object on the heap. "hello" uses the string pool (also heap, but shared).

Q: Why is stack faster than heap?

A: Stack uses LIFO allocation with no GC needed. Just move a pointer. Heap requires allocation, garbage collection, and more complex management.