Java Stack vs Heap Memory Allocation
Last Updated : 03 Jun, 2025
In Java, memory allocation is primarily divided into two categories, i.e., Stack and Heap memory. Both are used for different purposes, and they have different characteristics.
- Stack Memory: This memory is used to store local variables, method calls, and reference data during program execution.
- Heap Memory: This memory is used to store objects and dynamic data allocated at runtime.
Difference Between Stack and Heap Memory in Java
| Stack | Heap |
|---|
| Memory is allocated in a contiguous block. | Memory is allocated in any random order. |
| Allocation and deallocation are automatic (handled by compiler). | Allocation and deallocation are manual (handled by programmer). |
| It is less costly | It is more costly |
| Its implementation is easy | Its implementation is hard |
| Access time is faster | Access time is slower |
Limited memory size may lead to shortage issues. | Can suffer from memory fragmentation due to dynamic allocation. |
| Stack provides excellent memory locality | Heap is adequate but not as efficient |
| Thread safe, data stored can only be accessed by the owner | Not thread safe, data stored is visible to all threads |
| Stack is fixed in size | Heap allows resizing as needed |
| Stack uses a linear data structure | Heap uses a hierarchical data structure |
| Static memory allocation is preferred in an array. | Heap memory allocation is preferred in the linked list. |
| Smaller than heap memory. | Larger than stack memory. |
Stack and Heap Memory Interaction in Java
The below diagram demonstrates the relationship between stack and the heap memory.
The above diagram illustrates how method calls and local variables are stored in the stack memory, while objects and string literals are stored in the heap memory. The references in the stack point to the respective objects in the heap by showing the relationship between method execution and object storage.
Stack Memory Allocation in Java
Stack memory is temporary memory used for function calls. It automatically allocates memory when a function starts and clears it when the function ends. Programmers do not need to manage it manually. Data in stack memory exists only during the function's execution. If the stack runs out of space, a StackOverflowError occurs.
Example: This example demonstrates the local variable such as method parameters and variables declared inside methods, are stored in the stack memory.
Java // Java program to demonstrate the // local variables in the stack memory import java.io.*; class Geeks { public static int add(int a, int b) { // local variabel are stored in the stack int res = a + b; return res; } public static void main(String[] args) { // Local variables are stored in the stack int a = 10; int b = 20; int sum = add(a, b); System.out.println("The sum is: " + sum); } } Explanation: Here, method parameters and variables a, b, and res are stored in the stack memory. Once the method execution ends, the memory is automatically deallocated.
Heap Memory Allocation in Java
Heap memory play important role in Java. When we create an object using new keyword, memory is allocated for that object in the heap. The size of an object depends on the fields and data types define in its class. The JVM calculates how much space is needed based on the object's structure. Heap Memory is divided into so many regions:
- Young Generation: The area within the heap where new objects are generally allocated.
- Old Generation: The area within the heap where long lived objects are stored after surviving multiple garbage collection cycle.
- Permanent Generation: It stores meta data about classes and methods.
- Survivor space: It is a part of heap memory Young Generation where objects that survive garbage collection in the Eden Space are moved.
- Code cache: It is the special memory outside the heap where JVM stores optimized code to make programs run faster.
When the "new" is called JVM allocates memory for that object in the heap. The garbage collector automatically deletes objects that are no longer needed.
Scanner sc = new Scanner(System.in)
Here, the Scanner object is stored in the heap and the reference sc is stored in the stack.
Note: Garbage collection in the heap area is mandatory for automatic memory management.
Example: This example demonstrates how objects are stored in the heap while their references are stored in the stack.
Java // Java program to demonstrate the storage // of objects in heap memory import java.io.*; class Student { String name; int age; Student(String name, int age) { this.name = name; this.age = age; } } public class Geeks { public static void main(String[] args) { // Here the student object will be stored in the // heap memory and the references will be stored in // the stack memory Student s = new Student("Ram", 20); } } Explanation: Here, the Student object is allocated in the heap memory. The reference s which points to the object is stored in the stack memory.