Java developers have used the finalize() method for years to handle cleanup operations before an object is garbage collected. But in 2025, does the finalize() method in Java still hold any relevance? With advancements in garbage collection and alternative resource management techniques, many developers question its necessity.

In this blog post, we’ll explore the finalize() method in Java, understand its purpose, see why it has been deprecated, and examine better alternatives.

What is the Java finalize() Method?

The java finalize() method is a special method in Java that belongs to the Object class. It is called by the garbage collector before an object is destroyed. This method was originally designed to provide a mechanism for resource cleanup, such as closing file streams or releasing memory.

Syntax of finalize()

protected void finalize() throws Throwable {
    // Cleanup code
}

Since every class in Java implicitly extends Object, it can override finalize() to perform custom cleanup operations before an object is garbage collected.

How Does finalize() Work?

The java finalize() method is invoked by the Garbage Collector (GC) before an object is removed from memory. However, it is not guaranteed when (or if) it will be executed, making it unreliable for critical cleanup tasks.

class Demo {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalize() method called");
    }
}

public class FinalizeExample {
    public static void main(String[] args) {
        Demo obj = new Demo();
        obj = null; // Make the object eligible for garbage collection
        System.gc(); // Suggest the JVM to run garbage collection
        System.out.println("End of main method");
    }
}

Here,

1. An instance of Demo is created.
2. The reference is set to null, making it eligible for garbage collection.
3. System.gc() is called to request garbage collection (not guaranteed to run immediately).
4. If the garbage collector runs, finalize() executes before the object is destroyed.

Note: When you run the code, you will see one warning as well: ‘Warning: [removal] finalize() in Object has been deprecated and marked for removal.’

warning: [removal] finalize() in Object has been deprecated and marked for removal  
protected void finalize() throws Throwable {  
^

Why is finalize() Deprecated?

Starting with Java 9, the java finalize() method was deprecated due to several issues:

1. Unpredictability: The garbage collector decides when to execute finalize(), making it unreliable for resource management.
2. Performance Overhead: finalize() adds extra processing time, slowing down garbage collection.
3. Security Risks: Malicious code could exploit finalize() to resurrect objects, leading to potential security vulnerabilities.
4. Better Alternatives Exist: Modern Java provides try-with-resources and PhantomReferences for safer and more efficient resource cleanup.

Note: In Java 18, finalize() wasn’t completely removed, but it was officially marked for removal. Java Enhancement Proposal (JEP) 421 introduced in Java 18 deprecated finalization, signaling that it will be removed in a future version. So while finalize() still exists in Java 18, developers should avoid using it and switch to better alternatives.

Modern Alternatives to finalize()

1. Using try-with-resources (For Auto-Closeable Resources)

Java introduced try-with-resources in Java 7, which automatically closes resources without needing finalize().

import java.io.FileWriter;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (FileWriter writer = new FileWriter("path\test.txt")) {
            writer.write("Hello, Java!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Why is it Better?

• Ensures resources are closed immediately after use.
• No dependency on garbage collection.
• Improves code readability and performance.

2. Using PhantomReference (For Advanced Cleanup)

If you need to execute cleanup tasks after an object is garbage collected, PhantomReference is a better alternative.

import java.lang.ref.*;

public class PhantomReferenceExample {
    public static void main(String[] args) {
        ReferenceQueue<MyObject> queue = new ReferenceQueue<>();
        MyObject obj = new MyObject();
        PhantomReference<MyObject> phantomRef = new PhantomReference<>(obj, queue);
        obj = null;
        System.gc();
        System.out.println("Phantom reference added to queue: " + (queue.poll() != null));
    }
}
class MyObject {
    @Override
    protected void finalize() {
        System.out.println("Finalizing MyObject");
    }
}

Why is PhantomReference Better?

• Provides better control over garbage collection.
• Avoids unpredictability of finalize().
• Allows cleanup logic to execute only when necessary.

Is finalize() Still Relevant in 2025?

The short answer is no. With its deprecation and removal in newer Java versions, the java finalize() method is no longer a recommended practice. Java developers should use try-with-resources for automatic resource management and PhantomReference for advanced memory cleanup.

Conclusion

The java finalize() method was once a useful tool, but its unpredictable behavior and performance issues have made it obsolete. Modern alternatives like try-with-resources and PhantomReference offer safer and more efficient ways to handle resource cleanup. As of 2025, Java developers should completely avoid finalize() and adopt best practices that align with modern Java standards.

Do you still have legacy code using finalize()? It’s time to refactor and future-proof your Java applications!