Class Memory in Java

Structure of Class in Memory

Every single class of a Java program gets converted into bytecode when the Java program gets compiled. The main purpose of bytecode is to store the instructions that will be executed by the Java Virtual Machine (JVM). The Class object is responsible for containing all the information and data regarding structure of class, methods, fields, and several metadata.

Class Loading

A dynamic class loading mechanism is followed by Java. The JVM loads all the classes that are required and utilized during the runtime of a Java program. All the class files are found and loaded by the subsystem of class loader. Various class loaders are available such as Bootstrap class loader, Extension class loader, etc. All types of class loaders work collectively for loading classes in the memory allocated to the Java Virtual Machine (JVM).

Let's understand in detail about class memory in Java with the help of few Java example programs.

Example 1:

Filename: ClassMemory.java

// Java program for demonstrating the features and functionalities of Class memory in Java
class ParentClass {
    private String data;
    public ParentClass(String data) {
        this.data = data;
    }
    public void classTask() {
        // Simulating a complex task with additional data
        for (int i = 0; i < 100; i++) {
            this.data += i;
        }
    }
}
public class ClassMemory {
    private int int_Value;
    private String string_Value;
    private ParentClass functionality;
    public ClassMemory(int int_Value, String string_Value) {
        this.int_Value = int_Value;
        this.string_Value = string_Value;
        this.functionality = new ParentClass("AdditionalData");
    }
    public void display_Memory_Usage() {
        long total_Memory = Runtime.getRuntime().total_Memory();
        long free_Memory = Runtime.getRuntime().free_Memory();
        long used_Memory = total_Memory - free_Memory;
        System.out.println("Total Memory Allocated: " + total_Memory + " bytes");
        System.out.println("Free Memory Allocated: " + free_Memory + " bytes");
        System.out.println("Used Memory Allocated: " + used_Memory + " bytes");
        System.out.println("------------------------");
    }
    public void additional_Task() {
        for (int i = 0; i < 100; i++) {
            this.int_Value += i;
            this.string_Value += "X";
        }
        this.functionality.classTask();
    }
    public static void main(String[] args) {
        // Creation of an array of objects
        ClassMemory[] object_Array = new ClassMemory[1000];
        // Creation of an array of ParentClass objects
        ParentClass[] functionality_Array = new ParentClass[500];
        // Display memory usage before creating the objects
        System.out.println("Memory Usage Before Creating Objects:");
        new ClassMemory(0, "").display_Memory_Usage();
        // Creation objects and store them in the array
        for (int i = 0; i < object_Array.length; i++) {
            object_Array[i] = new ClassMemory(i, "Object" + i);
        }
        // Creation ParentClass objects and store them in the array
        for (int i = 0; i < functionality_Array.length; i++) {
            functionality_Array[i] = new ParentClass("Functionality" + i);
        }
        // Printing memory usage and allocation after creating the objects
        System.out.println("Memory Usage After Creating Objects:");
        object_Array[0].display_Memory_Usage();
        for (ClassMemory obj : object_Array) {
            obj.additional_Task();
        }
        // Printing memory usage after performing additional work
        System.out.println("Memory Usage After Performing Additional Work:");
        object_Array[0].display_Memory_Usage();
        for (int i = 0; i < object_Array.length / 2; i++) {
            object_Array[i] = null; 
        }
        // Triggering garbage collection manually using System.gc() method.
        System.gc();
        // Printing the memory usage after garbage collection
        System.out.println("Memory Usage After Garbage Collection:");
        object_Array[0].display_Memory_Usage();
    }
}

Output:

Memory Usage Before Creating Objects:
Total Memory: 123731968 bytes
Free Memory: 121716432 bytes
Used Memory: 2015536 bytes
------------------------
Memory Usage After Creating Objects:
Total Memory: 123731968 bytes
Free Memory: 121150408 bytes
Used Memory: 2581560 bytes
------------------------
Memory Usage After Performing Additional Work:
Total Memory: 123731968 bytes
Free Memory: 118347160 bytes
Used Memory: 5384808 bytes

Let's see another example for the same.

Filename: ClassMemoryDemo.java

class ChildClass {
    private double value;
    public ChildClass(double value) {
        this.value = value;
    }
    public void performTask() {
        for (int i = 0; i < 50; i++) {
            this.value *= i;
        }
    }
}
public class ClassMemoryDemo {
    private long longValue;
    private String stringValue;
    private ChildClass functionality;
    public ClassMemoryDemo(long longValue, String stringValue) {
        this.longValue = longValue;
        this.stringValue = stringValue;
        this.functionality = new ChildClass(3.14);
    }
    public void displayMemoryUsage() {
        long totalMemory = Runtime.getRuntime().totalMemory();
        long freeMemory = Runtime.getRuntime().freeMemory();
        long usedMemory = totalMemory - freeMemory;
        System.out.println("Total Memory Allocated: " + totalMemory + " bytes");
        System.out.println("Free Memory Allocated: " + freeMemory + " bytes");
        System.out.println("Used Memory Allocated: " + usedMemory + " bytes");
        System.out.println("------------------------");
    }
    public void additionalTask() {
        for (int i = 0; i < 50; i++) {
            this.longValue += i;
            this.stringValue += "Y";
        }
        this.functionality.performTask();
    }
    public static void main(String[] args) {
        // Creation of an array of objects
        ClassMemoryDemo[] objectArray = new ClassMemoryDemo[1000];
        // Creation of an array of ChildClass objects
        ChildClass[] functionalityArray = new ChildClass[500];
        // Display memory usage before creating the objects
        System.out.println("Memory Usage Before Creating Objects:");
        new ClassMemoryDemo(0, "").displayMemoryUsage();
        // Creating objects and storing them in the array
        for (int i = 0; i < objectArray.length; i++) {
            objectArray[i] = new ClassMemoryDemo(i, "Object" + i);
        }
        // Creating ChildClass objects and storing them in the array
        for (int i = 0; i < functionalityArray.length; i++) {
            functionalityArray[i] = new ChildClass(2.71);
        }
        // Printing memory usage and allocation after creating the objects
        System.out.println("Memory Usage After Creating Objects:");
        objectArray[0].displayMemoryUsage();
        for (ClassMemoryDemo obj : objectArray) {
            obj.additionalTask();
        }
        // Printing memory usage after performing additional work
        System.out.println("Memory Usage After Performing Additional Work:");
        objectArray[0].displayMemoryUsage();
        for (int i = 0; i < objectArray.length / 2; i++) {
            objectArray[i] = null;
        }
        // Triggering garbage collection manually using System.gc() method.
        System.gc();
        // Printing the memory usage after garbage collection
        System.out.println("Memory Usage After Garbage Collection:");
        objectArray[0].displayMemoryUsage();
    }
}

Output:

Memory Usage Before Creating Objects:
Total Memory Allocated: 123731968 bytes
Free Memory Allocated: 121716432 bytes
Used Memory Allocated: 2015536 bytes
------------------------
Memory Usage After Creating Objects:
Total Memory Allocated: 123731968 bytes
Free Memory Allocated: 121150400 bytes
Used Memory Allocated: 2581568 bytes
------------------------
Memory Usage After Performing Additional Work:
Total Memory Allocated: 123731968 bytes
Free Memory Allocated: 117522224 bytes
Used Memory Allocated: 6209744 bytes
------------------------

Next TopicConvert Byte to an Image in Java

← prev next →