Heap memory in Java - Step-by-Step Execution

flowchart

Concept Flow - Heap memory

Start Program Execution

↓

Allocate Objects on Heap

↓

Store References on Stack

↓

Use Objects via References

↓

Garbage Collector Frees Unused Objects

↓

Program Ends

This flow shows how Java allocates objects in heap memory, stores references on the stack, uses objects, and frees unused objects with garbage collection.

code_blocks

Execution Sample

Java

class Demo {
  public static void main(String[] args) {
    String s = new String("Hello");
    s = null;
  }
}

This code creates a String object on the heap and then removes the reference, making it eligible for garbage collection.

data_table

Execution Table

Step	Action	Heap State	Stack State	Garbage Collection
1	Start main method	Empty	args reference created	No
2	Create new String object "Hello"	["Hello"]	s -> "Hello"	No
3	Set s = null	["Hello"]	s -> null	Eligible for GC
4	End main method	Heap may free "Hello"	Stack cleared	Yes

💡 Program ends, heap objects without references are freed by garbage collector

search_insights

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
s	undefined	"Hello"	null	null
Heap Objects	empty	["Hello"]	["Hello"]	may be freed

key

Key Moments - 3 Insights

▶Why does the String object still exist on the heap after s is set to null?

▶What happens to the stack when main method ends?

▶Is the heap memory freed immediately after setting s to null?

psychology

Visual Quiz - 3 Questions

Look at the execution table, what is the value of variable 's' after step 2?

A "Hello"

B null

C undefined

D Garbage collected

photo_camera

Concept Snapshot

Heap memory stores objects created with 'new'.
References to these objects live on the stack.
Objects remain in heap until no references point to them.
Garbage collector frees unreferenced objects automatically.
Setting a reference to null removes one pointer but does not free memory immediately.

contract

Full Transcript

In Java, when the program runs, objects created with 'new' are stored in heap memory. Variables like 's' hold references to these objects on the stack. When 's' is assigned a new object, the heap stores that object and 's' points to it. If 's' is set to null, the reference is removed, but the object stays in heap until the garbage collector frees it. When the main method ends, all stack references are cleared, allowing the garbage collector to clean up unused objects. This process helps manage memory automatically without manual freeing.