Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/how-are-java-objects-stored-in-memory/ below:

How are Java Objects Stored in Memory?

Last Updated : 23 Jul, 2025

In Java, memory management is handled by the Java Virtual Machine (JVM). The breakdown of how objects are stored in memory:

• All Java objects are dynamically stored in the heap memory.
• References to these objects are stored in the stack memory.
• Objects are created using the "new" keyword and are allocated in the heap memory.
• Declaring a variable of a class type does not create an object it only creates references.
• To allocate memory for the object in heap, we need to use the "new" keyword.

The Java Virtual Machine is responsible for memory management in Java and divides memory into several areas:

• Heap Memory: Stores actual objects.
• Stack Memory: Stores method call data, local variables, and references.
• Other Areas: Include method area, metaspace (from Java 8), etc.

Now, let us go through each of the memory areas in detail.

Heap memory is a part of Java memory management. When an object is created using the new keyword, Java allocates space for that object in the heap. The amount of memory allocated depends on the fields defined in the object's class and their respective data types.

Scanner sc = new Scanner(System.in)

Here, the Scanner object is stored in the heap, and the reference sc is stored in the stack

Note: Garbage collection in the heap area is mandatory for automatic memory management.

Heap Memory is divided into several regions:

• Young Generation: The area within the heap where new objects are generally allocated.
• Old Generation: The area within the heap where long-livedmetadata Objects are stored after surviving multiple garbage collection cycles.
• Permanent Generation: It stores metadata about classes and methods in Java 7 and earlier versions.

Starting with Java 8, the old permanent generation space was removed and replaced by metaspace. Metaspace uses native memory outside the main heap. This change helps Java to handle class metadata better and also reduces the chances of errors caused by permanent generation.

When the new keyword is called, the JVM allocates memory for that object in the heap. The garbage collector automatically deletes objects that are no longer needed.

Example:

// Java program to demonstrate where the 
// objects are stored in the memory
import java.io.*;

class Student {
    String name;
    int age;

    Student(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
}

public class Geeks {
    public static void main(String[] args)
    {
        // Here the student object will be stored in the
        // heap memory and the references will be stored in
        // the stack memory
        Student s = new Student("bob", 20);
    }
}

Explanation: Here, the Student object is allocated in the heap memory. The reference s which points to the object is stored in the stack memory.

In Java, Stack memory is used to store local variables, method calls and references to an object. Each time a method is called, a new stack frame is created to hold local variables and object references. The stack memory is managed automatically, when a method finishes the stack frame is removed and the space used by its local variable is also released.

Note:

• Stack memory stores references to objects not the object themselves.
• Primitive data types and local variables are stored in the stack.
• Each thread in Java application has its own stack.

// Java program to demonstrate where 
// the objects are stored in the memory
import java.io.*;

public class Geeks {

    // method parameter 'n' is stored in the stack
    public static int calculate(int n)
    {
        // local varaible 'ans' is stored in the stack
        int ans = n * 10;
        return ans;
    }
    public static void main(String[] args)
    {
        // local variable 'n' is stored in the stack
        int n = 10;

        // n is passed as an argument so its reference is
        // stored in the stack
        calculate(n);
    }
}

Note: Local variables, primitive data types like int, double, etc. are stored in the stack when declared as local variables. However, the objects are stored in the heap and their references are stored in the stack.

In Java, The garbage collector is responsible for reclaiming memory by destroying objects that are no longer in use. When an object becomes unreachable that means no active reference points to it, it then becomes eligible for garbage collector. The garbage collector removes those objects freeing up the memory in the heap.

• Serial Garbage Collector: It is the simplest type of garbage collector. It uses a single thread to handle all garbage collection tasks.
• Parallel Garbage Collector: It is the default garbage collector in Java 8. It uses multiple threads to perform garbage collection tasks.
• Concurrent Mark-Sweep Collector: It is designed to minimize pause times by doing most of its work while the application is still running. It uses multiple threads to mark and clean up unreachable objects.
• G1 Garbage Collector: It was introduced in JDK 7 and became the default garbage collector in Java 9. Designed for applications with large heap sizes (greater than 4GB).
• Z Garbage Collector: It is designed to handle large heaps with minimal pause times, typically in the range of milliseconds.
• Shenandoah Garbage Collector: It is another low-pause-time garbage collector introduced in Java 12.
  

In Java, an object consist of three main parts:

• Object header: It contains metadata like the object's class and lock information for synchronization.
• Instance data: It refers to the actual fields or variables that belongs to an object.
• Padding: It refers to the extra memory to align the object size to the word size for better performance.

The object header includes:

• Class Pointer: This is a reference to the object's class.
• Lock Information: This is used for synchronization in multithreaded programs.
• GC-related Information: It is used by the garbage collector for managing the object lifecycle.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4