Overview

Memory management in Java is a powerful feature that handles memory allocation and deallocation automatically using garbage collection (GC). When you write any Java program, memory is automatically managed by the Java Virtual Machine (JVM). This memory is divided into Stack memory and Heap memory. This post will help you understand how Java memory works, the role of Heap and Stack memory, and how Garbage Collection ensures memory optimization — all essential for interviews and real-world projects

Why is Memory Management in Java Important?

Understanding memory management in java is crucial for:

• Good memory management help us to avoid memory leaks
• Its help us to Improve application or project performance
• Ensuring scalability and reliability in application
• Good memory management also help us to Handling high-traffic production systems

Java Memory Model Overview

Java memory is divided into two main areas:

Stack Memory in Java

Stack memory in Java is a part of the JVM memory where method calls, local variables, and reference variables are stored. Each thread in Java has its own stack, and this stack operates on a Last In First Out (LIFO) principle.

• Stack memory is used for the execution of a thread.
• It stores primitive values and references to objects in the heap.
• Memory allocation is Last In First Out (LIFO).

Key Features of Stack Memory:

Stack memory in Java is a part of the JVM memory where method calls, local variables, and reference variables are stored. Each thread in Java has its own stack, and this stack operates on a Last In First Out (LIFO) principle.

• Thread-specific – Each thread gets its own stack memory.
• Fast Access – Accessing data from the stack is faster than from the heap.
• Auto Cleanup – Memory is automatically deallocated when the method completes.
• Limited Size – this memory is limited and may lead to StackOverflowError.
• Stores Local Data – Stores local variables, method parameters, and object references (not objects themselves).

What is Stored in Stack Memory?

Let’s break it down simply:

• Primitive data types (int, boolean, char, etc.) defined inside a method
• References to objects (actual objects are stored in the heap)
• Function/method call details

public class StackExample {

    public static void main(String[] args) {

        int number = 10;   // Stored in stack

        String name = "Aman"; // Reference in stack, actual String object in heap

        display(number);

    }

    static void display(int n) {

        int square = n * n;  // Stored in stack for 'display' method

        System.out.println(square);

    }

}

StackOverflowError Example

Because stack memory is limited, deep or infinite recursion can lead to a StackOverflowError.

public class OverflowExample {

    public static void main(String[] args) {

        callAgain();

    }

    static void callAgain() {

        callAgain(); // Infinite recursion - StackOverflowError

    }

}

Heap Memory in Java

Heap memory is a region of JVM memory where all Java objects, class instances, and arrays are stored. Whenever you use the new keyword to create an object, it’s allocated in the heap.

The heap is shared among all threads, and its memory is managed by the Garbage Collector (GC) in Java.

Key Features of Stack Memory :

Stack memory in Java is a part of the JVM memory where method calls, local variables, and reference variables are stored. Each thread in Java has its own stack, and this stack operates on a Last In First Out (LIFO) principle.

• Shared Across Threads – Unlike stack, the heap is common for all threads
• Used for Objects – Stores all objects and their instance variables
• Managed by GC – JVM automatically frees memory through Garbage Collection
• Dynamic in Size – Heap size can be increased using JVM arguments
• Slower than Stack – Due to dynamic allocation and GC overhead.

Example of Heap Memory Usage

public class HeapExample {

    public static void main(String[] args) {

        // This object will be stored in the heap, the reference will be stored in the stack.

        Student s1 = new Student("Aman");

    }

}

class Student {

    String name;

    Student(String name) {

        this.name = name;

    }

}

🔎 In the above example:

• The Student object is created in heap memory
• The variable s1 (reference to the object) is stored in stack memory

What is OutOfMemoryError?

When the heap runs out of space and GC can’t free enough memory, Java throws:

    java.lang.OutOfMemoryError: Java heap space

Example

import java.util.ArrayList;
import java.util.List;

public class OOMDemo {

    public static void main(String[] args) {

        List<int[]> list = new ArrayList<>();

        while (true) {

            list.add(new int[1000000]); // Keep adding large arrays

        }

    }

}

⚠️ This code will eventually crash due to heap memory exhaustion.

How Heap Memory is Cleaned — Garbage Collection

Java automatically removes unused objects from the heap using Garbage Collection (GC).

Garbage Collector works in phases:

• Mark: Identifies unused objects
• Sweep: Removes unreferenced objects
• Compact: Rearranges memory for optimization

Java Garbage Collection (GC)

What is Garbage Collection?

• Garbage collection is the process of identifying and removing unused objects from memory to reclaim heap space.
• Java provides automatic garbage collection, so you don’t need to explicitly delete objects.

Key Concepts:

• Unreachable objects are removed by GC.
• Mark and Sweep is the most common algorithm.
• Objects are eligible for GC when there are no active references to them.

🧪 Example of Eligible for GC:

Student s1 = new Student();

s1 = null;  // now eligible for GC

 JVM Memory Areas (Diagram)

JVM Memory

├── Stack (Per Thread)
│   └── Local variables, method calls

├── Heap (Shared)
│   └── Objects, arrays, class instances

├── Method Area
│   └── Class definitions, static variables

├── PC Register
│   └── Current thread instruction

├── Native Method Stack
│   └── Native code (C/C++)

Types of Garbage Collectors in Java

Java provides several GC algorithms:

Conclusion

Understanding Java’s memory management — from stack and heap to garbage collection — is essential for writing efficient and scalable Java applications. Whether you’re preparing for interviews or building enterprise systems, mastering these concepts gives you a major edge.

Frequently asked questions in Java interviews