When you run a Java program, your computer uses two main areas of memory: the stack and the heap. The stack is where Java stores information about the methods you are calling and local variables inside those methods. The heap is where Java keeps objects that you create with the new keyword, like new String() or new ArrayList<>(). The stack is fast and automatically managed, but only holds temporary data for running methods. The heap is larger and holds data that needs to last longer, such as objects you use throughout your program. Understanding how the stack and heap work helps you write more efficient and reliable Java code.

Stack and Heap in Action: Web Request Processing

When you build a web application in Java, each user request is typically handled by a separate thread. Understanding how stack and heap memory work helps you write more reliable and efficient code.

Stack memory stores method calls and local variables for each thread. Heap memory stores objects created with the new keyword; these objects can be shared across methods and threads if referenced accordingly.

Consider a simple web request handler:

package com.example;

public class WebRequestHandler {
    public void handleRequest(String userInput) {
        // userInput is stored on the stack
        User user = new User(userInput); // user object is created on the heap
        logUser(user); // user reference is passed to another method
    }

    private void logUser(User user) {
        // user reference is on the stack, points to the User object on the heap
        System.out.println("User: " + user.getName());
    }
}

class User {
    private String name;
    public User(String name) { this.name = name; }
    public String getName() { return name; }
}

Key points:

• Each thread handling a request has its own stack.
• Local variables like userInput and user references live on the stack;
• The actual User object and its name field live on the heap;
• When a method finishes, its stack frame and local variables are removed, but heap objects remain if referenced elsewhere.

Why this matters:

• Excessive use of large local variables can cause stack overflow errors;
• Heap memory leaks can occur if objects are unintentionally kept referenced, increasing memory usage and slowing down the application.

By knowing what lives on the stack and what lives on the heap, you can design Java applications that are both efficient and robust.