Stack memory in Java

Introduction

Stack memory helps your program keep track of what it is doing step-by-step. It stores information about method calls and local variables so your program can run smoothly.

When a method calls another method and you need to remember where to come back.

When you want to store temporary data like local variables inside a method.

When you use recursion and need to keep track of each recursive call.

When you want to understand how your program uses memory during execution.

When debugging to see the order of method calls and variable values.

Syntax

Java

public class StackMemoryExample {
    public static void main(String[] args) {
        int number = 5; // stored in stack
        int result = factorial(number); // method call stored in stack
        System.out.println("Factorial of " + number + " is " + result);
    }

    public static int factorial(int n) {
        if (n == 0) {
            return 1; // base case
        } else {
            return n * factorial(n - 1); // recursive call
        }
    }
}

Each method call creates a new stack frame that holds its local variables and return address.

Stack memory is limited in size and follows Last In First Out (LIFO) order.

Examples

This example shows simple method calls and local variables stored in stack memory.

Java

public class StackMemoryExample {
    public static void main(String[] args) {
        int a = 10; // stored in stack
        int b = 20; // stored in stack
        int sum = add(a, b); // method call stored in stack
        System.out.println("Sum: " + sum);
    }

    public static int add(int x, int y) {
        return x + y;
    }
}

This example shows recursion where each call adds a new frame to the stack until the base case is reached.

Java

public class StackMemoryExample {
    public static void main(String[] args) {
        int number = 3;
        int result = factorial(number);
        System.out.println("Factorial: " + result);
    }

    public static int factorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }
}

When the program starts, the main method's stack frame is created. If it does nothing, the stack frame is still created and removed when main ends.

Java

public class StackMemoryExample {
    public static void main(String[] args) {
        // Empty main method
    }
}

Sample Program

This program calculates the factorial of a number using recursion. Each recursive call uses stack memory to store its own local variable 'n' and return address. When the base case is reached, the calls return one by one, freeing stack frames.

Java

public class StackMemoryDemo {
    public static void main(String[] args) {
        System.out.println("Program started");
        int number = 4;
        System.out.println("Calculating factorial of " + number);
        int factorialResult = factorial(number);
        System.out.println("Factorial of " + number + " is " + factorialResult);
        System.out.println("Program ended");
    }

    public static int factorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }
}

Important Notes

Time complexity of recursive factorial is O(n) because it calls itself n times.

Stack memory size is limited; too many recursive calls can cause a StackOverflowError.

Common mistake: forgetting the base case in recursion causes infinite calls and stack overflow.

Use stack memory for temporary data and method calls; use heap memory for objects that live longer.

Summary

Stack memory stores method calls and local variables in a Last In First Out order.

Each method call creates a new stack frame that is removed when the method finishes.

Recursion uses stack memory heavily, so always have a base case to avoid errors.

Practice

1. What does stack memory primarily store in Java?

easy

A. Method calls and local variables

B. Objects and class variables

C. Static variables and constants

D. Files and network connections

Solution

1. Step 1: Understand stack memory role

   Stack memory stores data related to method execution like local variables and method calls.

2. Step 2: Differentiate from heap memory

   Heap stores objects, while stack stores method calls and local variables.

3. Final Answer:

   Method calls and local variables -> Option A

4. Quick Check:

   Stack memory = method calls + local variables [OK]

Hint: Stack = method calls + local variables [OK]

Common Mistakes:

• Confusing stack with heap memory
• Thinking objects are stored in stack
• Mixing static variables with stack data

2. Which of the following is the correct way to declare a local variable inside a method in Java?

easy

A. static int x = 10;

B. local int x = 10;

C. var int x = 10;

D. int x = 10;

Solution

1. Step 1: Recall local variable syntax

   Local variables inside methods are declared simply with type and name, e.g., int x = 10;

2. Step 2: Identify invalid keywords

   Keywords like 'local' or 'var int' are invalid in Java, and 'static' is not allowed for local variables.

3. Final Answer:

   int x = 10; -> Option D

4. Quick Check:

   Local variable syntax = type + name + value [OK]

Hint: Local vars: type name = value; no extra keywords [OK]

Common Mistakes:

• Using 'local' keyword which doesn't exist
• Trying to use 'static' inside methods
• Confusing 'var' usage in older Java versions

3. What will be the output of this Java code?

public class Test {
  public static void main(String[] args) {
    int a = 5;
    int b = 10;
    int c = add(a, b);
    System.out.println(c);
  }
  public static int add(int x, int y) {
    return x + y;
  }
}

medium

A. 15

B. 510

C. Compilation error

D. Runtime error

Solution

1. Step 1: Trace method calls and parameters

   Main calls add(5, 10), passing values 5 and 10 as local variables on the stack.

2. Step 2: Calculate return value

   Add method returns 5 + 10 = 15, which is stored in c and printed.

3. Final Answer:

   15 -> Option A

4. Quick Check:

   5 + 10 = 15 [OK]

Hint: Add method returns sum; print result [OK]

Common Mistakes:

• Concatenating numbers as strings
• Confusing method parameters with global variables
• Expecting runtime or compile errors

4. Identify the error in this Java code related to stack memory usage:

public class Demo {
  public static void main(String[] args) {
    int result = factorial(4);
    System.out.println(result);
  }
  public static int factorial(int n) {
    if (n == 0) return 1;
    else return n * factorial(n - 1);
  }
}

medium

A. Stack overflow due to too many local variables

B. Missing base case causing infinite recursion

C. No error, code runs correctly

D. Incorrect method return type

Solution

1. Step 1: Check recursion base case

   The factorial method has a base case: if n == 0 return 1, stopping recursion.

2. Step 2: Confirm recursion correctness

   Each recursive call reduces n by 1, so recursion ends properly without stack overflow.

3. Final Answer:

   No error, code runs correctly -> Option C

4. Quick Check:

   Base case present, recursion safe [OK]

Hint: Check for base case to avoid stack overflow [OK]

Common Mistakes:

• Assuming missing base case when it exists
• Confusing local variables with stack overflow cause
• Thinking return type is wrong

5. Consider this recursive method that calculates the sum of numbers from n down to 1:

public static int sum(int n) {
  if (n <= 0) return 0;
  else return n + sum(n - 1);
}

What will happen if you call sum(1000000) in Java, and why?

hard

A. It will return the correct sum without issues

B. It will cause a stack overflow error due to deep recursion

C. It will run infinitely without stopping

D. It will cause a compile-time error

Solution

1. Step 1: Analyze recursion depth

   Calling sum(1000000) causes 1,000,000 recursive calls, each adding a stack frame.

2. Step 2: Understand stack memory limits

   Java's stack size is limited; deep recursion like this exceeds it, causing stack overflow error.

3. Final Answer:

   It will cause a stack overflow error due to deep recursion -> Option B

4. Quick Check:

   Deep recursion > stack size = stack overflow [OK]

Hint: Very deep recursion causes stack overflow error [OK]

Common Mistakes:

• Assuming recursion always works regardless of depth
• Thinking it runs infinitely without base case
• Confusing runtime errors with compile errors