Difference between Stack and Heap Memory in Java

In Java, memory management revolves around two main areas: the stack and the heap. These two areas serve different purposes and manage memory differently:

Stack Memory

1. Purpose:

   • The stack is used for static memory allocation.
   • It stores primitive values (e.g., int, char, boolean), references to objects, and method invocation frames.

2. Allocation:

   • Memory allocation and deallocation in the stack follows a Last In, First Out (LIFO) model.
   • Local variables, method parameters, and method calls are stored in the stack.

3. Size:

   • Stack memory is typically smaller in size compared to heap memory.
   • The size of the stack is fixed and set at the start of the program.

4. Access:

   • Access to stack memory is fast and efficient.
   • Memory allocation and deallocation are handled automatically by the compiler.

5. Lifetime:

   • The lifetime of variables in stack memory is short-lived. They exist as long as the method is executing.
   • When a method ends, the variables in the stack are popped off, and the memory is freed.

Heap Memory

1. Purpose:

   • The heap is used for dynamic memory allocation.
   • It stores objects (instances of classes) and arrays.

2. Allocation:

   • Memory allocation and deallocation in the heap are not as organized as in the stack.
   • Objects are allocated in the heap as needed and may exist longer than the method that created them.

3. Size:

   • Heap memory is larger compared to stack memory.
   • The size of the heap is dynamic and can grow or shrink during the program's execution.

4. Access:

   • Access to heap memory is comparatively slower than stack memory.
   • Garbage collection is performed in the heap to reclaim memory occupied by objects that are no longer referenced.

5. Lifetime:

   • Objects in heap memory may have a longer lifetime than stack-based variables.
   • They are accessible as long as they are referenced by some part of the program.

Example of Stack vs. Heap

public class MemoryExample {

    public static void main(String[] args) {

        // Stack variables

        int a = 10;

        String name = "Java";

        // Heap objects

        Object obj = new Object();  // Object created in heap

        int[] array = new int[5];   // Array created in heap

    }

}

• In the above example:
  • a and name are stored in stack memory.
  • obj and array are objects stored in heap memory.

Summary

• Stack is used for static memory allocation, faster access, and manages method execution flow.
• Heap is used for dynamic memory allocation, larger storage, and manages objects and arrays.

Understanding the differences between stack and heap memory helps in optimizing memory usage and designing efficient Java programs.