What is a StackOverflowError in Java?

In Java, a StackOverflowError is an unchecked exception that occurs when the call stack, which keeps track of method calls and their corresponding variables, exceeds its maximum limit. This error typically arises from an excessive recursion, where a method repeatedly calls itself without a proper exit condition, leading to an overflow of the stack memory.

When a method is invoked in Java, the JVM allocates a specific amount of memory on the call stack for that method's execution. This memory includes parameters, local variables, and other necessary information. As each method call is made, the JVM pushes a new frame onto the stack, and when a method completes its execution, the corresponding frame is popped off the stack.

If you have a function like:

int myFunction() { // your code myFunction(); }

In the above code myFunction() will keep calling itself, getting deeper and deeper, and when the space used to keep track of what functions you're in is filled up, you get the stackoverflow error . The common cause for a stack overflow is a bad recursive call. Typically, this is caused when your recursive functions doesn't have the correct termination condition, so it ends up calling itself forever.

However, if there is an unbounded recursion, where a method continues to call itself without terminating, the call stack grows indefinitely, eventually surpassing its predefined limit. At this point, a StackOverflowError is thrown by the JVM to indicate that there is no more stack memory available to accommodate additional method calls.

A common scenario leading to a StackOverflowError is when a recursive method lacks a proper base case or termination condition. Without an appropriate stopping criterion, the method repeatedly invokes itself, causing the call stack to grow excessively until it exceeds its capacity.

Reason for StackOverflowError

Parameters and local variables are assigned memory on the stack, residing at the higher end of the address space, while the heap, located at the lower end of the address space, dynamically expands as memory is allocated. However, there exists a possibility of the heap and stack overlapping, causing a collision. When the stack is unable to accommodate a new stack frame due to this collision, the Java Virtual Machine (JVM) raises a StackOverflowError.

  1. If the stack is full you can't push, if you do you'll get stack overflow error.
  2. If the stack is empty you can't pop, if you do you'll get stack underflow error.

How to solve?

To resolve a StackOverflowError, it is crucial to identify and rectify the recursive method causing the issue. This can involve adding a termination condition or revising the recursive logic to ensure that the method does not endlessly call itself. By addressing the root cause of the error, the program can avoid stack overflow situations and operate correctly.


The depth of the call stack can vary depending on the JVM implementation and available memory. Therefore, the threshold for a StackOverflowError may differ across different platforms and configurations.