Java

Strings are one of the most used data types in Java. Whether you’re working on backend logic, building APIs, or creating user interfaces, you’ll constantly manipulate text. Mastering Java Strings is not just about knowing how to declare them — it’s about using the right methods efficiently.

In this guide, we’ll break down 15 essential String methods in Java.

What Are Java Strings?

In Java, a String is an object that represents a sequence of characters. Unlike primitive types (like int or char), Strings are immutable—once created, they cannot be changed.

For example:

String name = "Java";

Here, "Java" is a String object. Any operation you perform on it will create a new String instead of modifying the existing one. This immutability ensures safety and consistency but also means you should know which methods to use efficiently.

1. length()

Returns the number of characters in a string.

String text = "Hello World";
System.out.println(text.length()); // Output: 11

Why it matters: You’ll often need to check string sizes for validation, formatting, or loops.

2. charAt(int index)

Returns the character at the given position (index starts from 0).

String word = "Java";
System.out.println(word.charAt(2)); // Output: v

Pro tip: Use it for character-level operations like parsing or encryption.

3. substring(int beginIndex, int endIndex)

Extracts part of a string.

String str = "Mastering Java";
System.out.println(str.substring(0, 9)); // Output: Mastering

Use case: Extract names, IDs, or tokens from a larger text.

4. equals(Object another)

Checks if two strings are exactly equal (case-sensitive).

String a = "Java";
String b = "Java";
System.out.println(a.equals(b)); // Output: true

Tip: Use equalsIgnoreCase() when case doesn’t matter.

5. compareTo(String another)

Compares two strings lexicographically. Returns:

• 0 if equal
• < 0 if first < second
• > 0 if first > second

System.out.println("apple".compareTo("banana")); // Output: negative value

Why useful: Sorting and ordering strings.

6. contains(CharSequence s)

Checks if a string contains a sequence of characters.

String text = "Learning Java Strings";
System.out.println(text.contains("Java")); // Output: true

7. indexOf(String str)

Finds the first occurrence of a substring.

String sentence = "Java is powerful, Java is popular.";
System.out.println(sentence.indexOf("Java")); // Output: 0

Note: Returns -1 if not found.

8. lastIndexOf(String str)

Finds the last occurrence of a substring. Means, lastIndexOf gives the starting index of the last occurrence.

System.out.println(sentence.lastIndexOf("Java")); // Output: 18

Great for working with repeated values.

9. toLowerCase() and toUpperCase()

Convert strings to lower or upper case.

String lang = "Java";
System.out.println(lang.toLowerCase()); // java
System.out.println(lang.toUpperCase()); // JAVA

Perfect for case-insensitive searches or formatting.

10. trim()

Removes leading and trailing spaces.

String messy = "   Java Strings   ";
System.out.println(messy.trim()); // Output: Java Strings

Pro tip: Always trim user input before processing.

11. replace(CharSequence old, CharSequence new)

Replaces characters or substrings.

String data = "I love Python";
System.out.println(data.replace("Python", "Java")); // Output: I love Java

12. split(String regex)

Splits a string into an array based on a delimiter.

String csv = "apple,banana,grape";
String[] fruits = csv.split(",");
for (String fruit : fruits) {
    System.out.println(fruit);
}

Output:

apple  
banana  
grape

Useful in parsing CSV, logs, or user input.

13. startsWith(String prefix) / endsWith(String suffix)

Check if a string begins or ends with a specific sequence.

String file = "report.pdf";
System.out.println(file.endsWith(".pdf")); // true

14. isEmpty()

Checks if a string has no characters.

String empty = "";
System.out.println(empty.isEmpty()); // true

Note: After Java 6, isBlank() (Java 11+) is even better as it checks whitespace too.

15. valueOf()

Converts other data types into strings.

int num = 100;
String strNum = String.valueOf(num);
System.out.println(strNum + 50); // Output: 10050 ("100" + "50" → "10050")

Why useful: For concatenation and displaying numbers, booleans, or objects.

Best Practices with Java Strings

• Use StringBuilder or StringBuffer for heavy modifications (loops, concatenations).
• Always check for null before calling string methods.
• For large-scale text processing, be mindful of memory since Strings are immutable.

Conclusion

Mastering these Java String methods will make you faster and more confident when handling text in Java applications. Whether you’re validating user input, formatting reports, or parsing data, these 15 methods cover most real-world scenarios.

The key is practice. Start experimenting with these methods in small projects, and you’ll soon find that strings are not just simple text — they’re a powerful tool in every Java developer’s toolkit.

When multiple threads run at the same time in Java, they often try to access the same resources — like a variable, object, or file. Without any control, this can cause unpredictable behavior and bugs that are hard to trace. That’s where the synchronized keyword in Java comes in.

In simple words, synchronized is a tool Java gives us to prevent multiple threads from interfering with each other while working on shared resources. Let’s break it down in a clear and practical way.

Why Do We Need the synchronized Keyword?

Imagine two people trying to withdraw money from the same bank account at the exact same time. If both transactions run without coordination, the account might go into a negative balance.

This type of problem is called a race condition. In Java, the synchronized keyword is used to avoid such situations by allowing only one thread at a time to access a block of code or method.

How Does synchronized Work?

When a thread enters a synchronized block or method, it locks the object it belongs to. Other threads trying to enter the same block or method must wait until the lock is released.

This locking mechanism ensures thread safety, but it also slows things down if used too often. That’s why it’s important to use it wisely.

Types of Synchronization in Java

There are two main ways to use the synchronized keyword in Java:

1. Synchronized Method — Entire method is synchronized.
2. Synchronized Block — Only a specific part of the code is synchronized.

Let’s look at both with examples.

Synchronized Method

class Counter {
    private int count = 0;

    // Synchronized method
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // Two threads incrementing the counter
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final Count: " + counter.getCount());
    }
}

• The increment() method is marked as synchronized.
• This means only one thread can execute it at a time.
• Without synchronization, the final count might not be 2000 due to race conditions.
• With synchronization, the output will always be 2000.

Run the program twice: once with synchronization enabled and once without. Compare the outputs to observe the effect of synchronization.

In this case, we will always get 2000 as the output in both scenarios.

Why the Result Can Still Be the Same (2000) Without Synchronization

When two threads increment the counter (count++), here’s what happens under the hood:

count++ is not atomic. It actually breaks down into three steps:

1. Read the current value of count.
2. Add 1 to it.
3. Write the new value back to memory.

If two threads interleave at the wrong time, one update can overwrite the other. That’s the race condition.

But… race conditions don’t guarantee wrong results every single run. Sometimes:

• The threads happen to run sequentially (one finishes a batch before the other interferes).
• The CPU scheduler doesn’t interleave them in a conflicting way.
• The number of operations is small, so the timing never collides.

In those cases, you might still get the “correct” result of 2000 by luck, even though the code isn’t thread-safe.

Why It’s Dangerous

The key point: the result is non-deterministic.

• You might run the program 10 times and see 2000 each time.
• But on the 11th run, you might get 1987 or 1995.

The behavior depends on CPU scheduling, thread timing, and hardware. That’s why without synchronization, the program is unsafe even if it sometimes looks fine.

How to Force the Wrong Behavior (to See the Bug)

If you want to actually see the race condition happen more often:

• Increase the loop count (e.g., 1000000 instead of 1000).
• Run on a machine with multiple cores.
• Add artificial delays (like Thread.yield() inside the loop).

You’ll quickly notice results less than 2000 when threads interfere.

Without synchronized, getting 2000 doesn’t mean the code is correct — it just means the timing didn’t trigger a race condition in that run. Synchronization guarantees correctness every time, not just by chance.

Synchronized Block

Sometimes, we don’t need to synchronize an entire method — just a small critical section of code. That’s where synchronized blocks are useful.

class Printer {
    public void printMessage(String message) {
        synchronized(this) {
            System.out.print("[" + message);
            try {
                Thread.sleep(100); // Simulate delay
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("]");
        }
    }
}

public class SyncBlockExample {
    public static void main(String[] args) {
        Printer printer = new Printer();

        Thread t1 = new Thread(() -> printer.printMessage("Hello"));
        Thread t2 = new Thread(() -> printer.printMessage("World"));

        t1.start();
        t2.start();
    }
}

• Only the block inside synchronized(this) is locked.
• This ensures that printing of messages happens in a safe, consistent way (e.g., [Hello] and [World], instead of jumbled outputs).
• Synchronizing just the critical section improves performance compared to locking the whole method.

Static Synchronization

If a method is declared as static synchronized, the lock is placed on the class object rather than the instance. This is useful when you want synchronization across all instances of a class.

class SharedResource {
    public static synchronized void showMessage(String msg) {
        System.out.println("Message: " + msg);
    }
}

Here, only one thread across all objects of SharedResource can access showMessage() at a time.

Pros and Cons of Using synchronized

Advantages

• Prevents race conditions.
• Ensures data consistency.
• Provides a simple way to handle multi-threading issues.

Disadvantages

• Can reduce performance because of thread blocking.
• May lead to deadlocks if not handled carefully.
• In large-scale systems, too much synchronization can become a bottleneck.

Best Practices for Using synchronized

• Synchronize only the critical section, not the entire method, when possible.
• Keep synchronized blocks short and efficient.
• Avoid nested synchronization to reduce deadlock risks.
• Consider higher-level concurrency tools like ReentrantLock or java.util.concurrent classes for complex scenarios.

Conclusion

The synchronized keyword in Java is a powerful tool to ensure thread safety. It allows you to control how multiple threads interact with shared resources, preventing errors like race conditions.

However, it’s not always the most efficient choice. Use it when necessary, but also explore modern concurrency utilities for more flexible and performant solutions.

If you’re just starting with multithreading in Java, mastering synchronized is the first step toward writing safe, concurrent programs.

When working with strings in Java, one of the most common checks we perform is whether a string is empty or not. For a long time, developers used different approaches such as comparing string length or trimming whitespace manually. Over the years, Java has introduced more direct methods to simplify these checks — most notably, isEmpty() in Java 6 and isBlank() in Java 11.

If you’ve ever wondered about the difference between these two methods, when to use each, and why isBlank() is often considered a better choice in modern Java, this guide will walk you through everything in detail.

A Quick Look at String Checking in Java

Before we dive deeper, let’s recall the basics. In Java, a string can be:

Null — it points to nothing in memory.

String s = null; // This is null, not an actual string object.

Calling s.isEmpty() or s.isBlank() here would throw a NullPointerException.

Empty — it is a valid string object, but its length is zero.

String s = ""; // length is 0

Whitespace-only — it contains characters, but only whitespace such as spaces, tabs, or line breaks.

String s = "   "; // length is 3, but visually it looks empty

Each of these cases needs different handling, and that’s where isEmpty() and isBlank() come into play.

isEmpty() – Introduced in Java 6

The method isEmpty() was added to the String class in Java 6. Its purpose is very straightforward: check if the string length is zero.

String s1 = "";
System.out.println(s1.isEmpty()); // true

String s2 = "   ";
System.out.println(s2.isEmpty()); // false

How it works internally:

public boolean isEmpty() {
    return this.length() == 0;
}

As you can see, isEmpty() does not consider whitespace-only strings as empty. A string with spaces still has a length greater than zero, so isEmpty() will return false.

isBlank() – Introduced in Java 11

Starting from Java 11, a new method isBlank() was introduced to address a long-standing gap. Many developers often wanted to check not just for empty strings, but also strings that only contain whitespace. That’s exactly what isBlank() does.

String s1 = "";
System.out.println(s1.isBlank()); // true

String s2 = "   ";
System.out.println(s2.isBlank()); // true

String s3 = "\n\t";
System.out.println(s3.isBlank()); // true

String s4 = "abc";
System.out.println(s4.isBlank()); // false

How it works internally:

public boolean isBlank() {
    return this.trim().isEmpty();
}

This is a simplified explanation — the actual implementation is more efficient and uses Unicode-aware checks, but the idea is the same.

isEmpty() vs isBlank() 

When Should You Use Each?

• Use isEmpty() when you want to strictly check if a string has zero characters.
   Example: validating input where whitespace still counts as data.
• Use isBlank() when you want to check if a string has no meaningful content (empty or only whitespace).
   Example: ignoring user input that’s just spaces or tabs.

In most real-world applications, especially in form validations and text processing, isBlank() is the safer choice.

Mimicking isBlank() in Java 6–10: Very Rare Now A Days

If you’re stuck on a version of Java earlier than 11, you can simulate isBlank() using a combination of trim() and isEmpty():

public static boolean isBlankLegacy(String input) {
    return input == null || input.trim().isEmpty();
}

This way, your code works almost the same as isBlank().

Key Takeaways

1. Java 6 introduced isEmpty(), which only checks if the string length is zero.
2. Java 11 introduced isBlank(), which goes further and treats whitespace-only strings as blank.
3. Prefer isBlank() when available, especially for user input validation.
4. For legacy versions of Java, you can mimic isBlank() using trim().isEmpty().

Conclusion

The addition of isBlank() in Java 11 might seem like a small feature, but it solves a very common problem in a clean, intuitive way. For developers, it means fewer bugs, less boilerplate code, and more readable string checks.

If you’re working in an environment where upgrading to Java 11 or above is possible, take advantage of isBlank(). It makes your code more expressive and avoids the subtle pitfalls that come with checking only for emptiness.

Pro Tip: Neither isEmpty() nor isBlank() handles null values. If your string could be null, check for null first using Objects.nonNull() or Optional to avoid a NullPointerException.

When you first start learning Java, you’ll quickly hear about the Object Class. It sounds simple, but it’s actually the backbone of the entire language. Every class in Java — whether you write it yourself or it comes from the Java library — directly or indirectly inherits from this class.

Let’s break down what that really means and why it matters.

What is the Object Class?

The Object Class is defined in the java.lang package. You don’t have to import it manually because Java automatically makes it available.

It’s the root class in Java, meaning all classes extend from it either:

• Explicitly (if you declare it), or
• Implicitly (if you don’t, Java does it for you).

In other words, if you create a class without specifying a parent, it silently extends Object.

class Car {
    String model;
    int year;
}

You might think Car has no parent, but under the hood, Java automatically treats it as:

class Car extends Object {
    String model;
    int year;
}

So, Car inherits everything from the Object Class even if you don’t mention it.

Why is the Object Class Important?

The Object Class ensures consistency across Java programs. Since every class inherits from it, Java provides a set of universal methods that all objects can use. This makes the language predictable and powerful.

Think of it like this: no matter what type of object you’re working with — String, ArrayList, or your custom Car class—you can always count on these core behaviors.

Common Methods of the Object Class

Here are some of the most important methods that come from Object Class:

1. toString()

Converts an object into a readable string.

class Car {
    String model;
    int year;

    Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    @Override
    public String toString() {
        return "Car Model: " + model + ", Year: " + year;
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Tesla", 2024);
        System.out.println(car.toString());
    }
}

Output:

Car Model: Tesla, Year: 2024

Without overriding, it would just show something like Car@15db9742, which isn’t very helpful.

2. equals()

Used to compare objects for equality.

class Car {
    String model;

    Car(String model) {
        this.model = model;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Car)) return false;
        Car other = (Car) obj;
        return this.model.equals(other.model);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("Tesla");
        Car car2 = new Car("Tesla");
        System.out.println(car1.equals(car2)); // true
    }
}

Here, we override equals() to compare values instead of memory references.

3. hashCode()

Works with equals() to provide efficient object comparison, especially in collections like HashMap or HashSet.

4. getClass()

Returns the runtime class of an object. Helpful in reflection or debugging.

Car car = new Car("Tesla");
System.out.println(car.getClass().getName());

Output:

Car

5. clone()

Creates a copy of an object. (Only works if a class implements the Cloneable interface.)

6. finalize()

Called by the garbage collector before destroying an object. (Rarely used today because modern garbage collection handles cleanup better.)

Why Java Needs a Single Root Class

Having the Object Class as the root provides:

• Uniformity: All objects share the same basic methods.
• Polymorphism: You can write methods that take Object as a parameter and accept any class type.
• Flexibility: Collections, frameworks, and APIs can operate on any object, making Java extremely versatile.

Example of polymorphism:

public void printObject(Object obj) {
    System.out.println("Object: " + obj.toString());
}

This method will work for any class — String, Integer, Car, or anything else—because they all inherit from Object Class.

Conclusion

The Object Class is the silent hero of Java. It’s always there, providing consistency and ensuring that every class — no matter how complex — shares the same foundation. By understanding it, you’ll write cleaner, smarter, and more reliable code.

So the next time you build a class, remember: it all starts with Object Class.

Java’s threading model can trip up even experienced developers. One of the most common sources of confusion? The difference between t.start() and t.run().

If you’ve ever written a multithreaded program in Java, you’ve likely encountered both. But what actually happens when you call t.start() instead of t.run() — and why does it matter?

Quick Answer: t.start() vs t.run()

• t.start(): Starts a new thread and executes the run() method in that new thread.
• t.run(): Calls the run() method in the current thread, just like a normal method.

Sounds simple, right? But the consequences are huge.

Let’s break it down with code examples and real-world implications.

A Little Threading Background

Java supports multithreading — the ability to run multiple threads (independent units of work) simultaneously. You can create threads by:

1. Extending the Thread class.
2. Implementing the Runnable interface.

In both cases, you override the run() method, which holds the code you want the thread to execute.

But here’s the twist: overriding run() doesn’t actually start the thread. That’s what start() is for.

t.start() vs t.run() in Action

public class Demo extends Thread {
    public void run() {
        System.out.println("Running in: " + Thread.currentThread().getName());
    }

public static void main(String[] args) {
        Demo t1 = new Demo();
        System.out.println("Calling t1.run()");
        t1.run();  // Executes in main thread
        System.out.println("Calling t1.start()");
        t1.start();  // Executes in new thread
    }
}

Output:

Calling t1.run()
Running in: main
Calling t1.start()
Running in: Thread-0

What’s Happening Here?

• t1.run() runs just like any regular method — in the main thread.
• t1.start() creates a new thread and calls run() in that thread.

That’s the real difference between t.start() vs t.run().

Why It Matters: Real-World Implications

1. Concurrency

Using t.start() enables true parallel execution. Your app can do multiple things at once.

Using t.run()? Everything runs sequentially in the same thread. No concurrency. Just like calling any other method.

2. Performance

On multi-core processors, t.start() lets Java take full advantage of your CPU. Each thread can run independently.

t.run()? No benefit — it runs synchronously, blocking other operations.

3. Thread Behavior

start() sets up everything: thread stack, scheduling, life cycle management.

run() bypasses that. You’re not creating a new thread; you’re just executing some code.

Common Mistakes to Avoid

Mistake 1: Using t.run() and expecting multithreading

Thread t = new Thread(() -> {
    System.out.println("Running in: " + Thread.currentThread().getName());
});

t.run(); // Looks like threading, but isn't!

You just called a method. No new thread is created. Use t.start() instead.

Mistake 2: Calling start() twice

Thread t = new Thread(() -> {
    System.out.println("Hello!");
});

t.start();  // OK
t.start();  // IllegalThreadStateException

Once a thread has been started, it can’t be restarted. You’ll get a runtime exception if you try.

Practical Tip: Always Use start() for Threads

If your goal is concurrency, always use start(). The only time you’d use run() directly is for testing or if you’re intentionally avoiding multithreading (rare).

Loop with Threads

for (int i = 0; i < 3; i++) {
    Thread t = new Thread(() -> {
        System.out.println("Running in: " + Thread.currentThread().getName());
    });
    t.start();  // Right choice
}

Want concurrency? Use start() — always.

t.start() vs t.run() in Java

When comparing t.start() vs t.run(), the key takeaway is this:

• start() kicks off a new thread.
• run() just runs the code in the current thread.

If you want real multithreading, go with t.start(). If you call t.run(), you’re just calling a method — no thread magic involved.

This difference is critical when building responsive, scalable Java applications — whether it’s for a web server, a game engine, or a background worker.

Key Takeaways

• t.start() creates a new thread and calls run() in it.
• t.run() runs like a normal method — no new thread.
• Always use start() to actually start threading.
• Don’t call start() more than once on the same thread.
• If it runs in the main thread, it’s not really multithreaded.

Conclusion

Understanding t.start() vs t.run() is foundational for writing efficient, concurrent Java programs. It’s not just about syntax — it’s about how your code executes in real time.

So next time you see run(), stop and ask: Am I actually starting a thread, or just calling a method?

If you want true multithreading, start() is your ticket.

Java is a strongly typed language, meaning it requires explicit type definitions to ensure reliability and stability in applications. One of the most powerful features Java provides to enforce type safety in Java is Generics. This guide will help you understand generics, how they enhance type safety, and how to use them effectively.

What Are Generics in Java?

Generics allow developers to create classes, interfaces, and methods that operate on different types while maintaining type safety in Java. With generics, you can write flexible and reusable code without compromising the reliability of type enforcement.

For example, before generics were introduced, Java collections stored objects as raw types, requiring explicit casting, which was both error-prone and unsafe.

Without Generics (Before Java 5)

import java.util.ArrayList;

public class WithoutGenerics {
    public static void main(String[] args) {
        ArrayList list = new ArrayList(); // Raw type list
        list.add("Hello");
        list.add(100); // No type safety
        String text = (String) list.get(0); // Safe
        String number = (String) list.get(1); // Runtime error: ClassCastException
    }
}

Have you noticed Problem Here:

• The ArrayList stores any object type (String, Integer, etc.), leading to runtime errors.
• Type casting is required when retrieving elements, otherwise, which increases the chance of ClassCastException.

How Generics Improve Type Safety in Java

With generics, you specify the type when defining a collection, ensuring only valid data types are added.

With Generics (Java 5 and Later)

import java.util.ArrayList;

public class WithGenerics {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(); // Type-safe list
        list.add("Hello");
        // list.add(100); // Compile-time error, preventing mistakes
        String text = list.get(0); // No explicit casting required
        System.out.println(text);
    }
}

Benefits of Generics:

1. Compile-time Type Checking: Prevents type-related errors at compile time instead of runtime.
2. No Need for Type Casting: Eliminates unnecessary type conversion, reducing code complexity.
3. Code Reusability: Generic methods and classes can work with multiple types without duplication.

Using Generics in Classes

You can define generic classes to work with different data types.

Creating a Generic Class

A generic class is a class that can work with any data type. You define it using type parameters inside angle brackets (<>).

class Box<T> { // T is a placeholder for a type
    private T value;
    
    public void setValue(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
}

public class GenericClassExample {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setValue("Java Generics");
        System.out.println(stringBox.getValue());
        Box<Integer> intBox = new Box<>();
        intBox.setValue(100);
        System.out.println(intBox.getValue());
    }
}

Here,

• T represents a generic type that is replaced with a real type (e.g., String or Integer) when used.
• The class works for any data type while ensuring type safety in Java.

Generic Methods

Generic methods allow flexibility by defining methods that work with various types.

Creating a Generic Method

You can define methods that use generics, making them more reusable.

class GenericMethodExample {
    public static <T> void printArray(T[] elements) {
        for (T element : elements) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"A", "B", "C"};
        
        printArray(intArray); // Works with Integer array
        printArray(strArray); // Works with String array
    }
}

Here,

• <T> before the method name defines a generic type.
• The method works with any array type (Integer, String, etc.), enhancing type safety in Java.

Bounded Type Parameters

Sometimes, you may want to restrict the generic type to a specific category, such as only numbers. This is done using bounded type parameters.

Restricting to Number Types

class Calculator<T extends Number> { // T must be a subclass of Number
    private T num;
    
    public Calculator(T num) {
        this.num = num;
    }
    
    public double square() {
        return num.doubleValue() * num.doubleValue();
    }
}

public class BoundedGenericsExample {
    public static void main(String[] args) {
        Calculator<Integer> intCalc = new Calculator<>(5);
        System.out.println("Square: " + intCalc.square());
        Calculator<Double> doubleCalc = new Calculator<>(3.5);
        System.out.println("Square: " + doubleCalc.square());
    }
}

• T extends Number ensures that T can only be a subclass of Number (e.g., Integer, Double).
• This ensures type safety in Java, preventing incompatible types like String from being used.

Wildcards in Generics

Wildcards (?) provide flexibility when working with generics. They allow methods to accept unknown generic types.

import java.util.*;

class WildcardExample {
    public static void printList(List<?> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
    }
    public static void main(String[] args) {
        List<Integer> intList = Arrays.asList(1, 2, 3);
        List<String> strList = Arrays.asList("A", "B", "C");
        
        printList(intList);
        printList(strList);
    }
}

Why Use Wildcards?

• ? allows passing any generic type.
• Helps achieve type safety in Java while maintaining flexibility.

Conclusion

Generics are a crucial feature in Java, enhancing type safety in Java by detecting errors at compile-time and reducing runtime exceptions. By using generics, developers can create reusable, maintainable, and efficient code. Whether you use generic classes, methods, bounded types, or wildcards, generics make Java programming safer and more powerful.

Memory management is a crucial aspect of Java programming, ensuring that unused objects are efficiently cleared to free up resources. While Java’s built-in garbage collector (GC) handles most of this automatically, advanced scenarios require finer control. This is where PhantomReference in Java comes into play.

In this blog post, we will explore PhantomReference in Java, how it differs from other reference types, and how it can be used to enhance memory management. Let’s dive in!

What is PhantomReference in Java?

A PhantomReference is a type of reference in Java that allows you to determine precisely when an object is ready for finalization. Unlike SoftReference and WeakReference, a PhantomReference does not prevent an object from being collected. Instead, it serves as a mechanism to perform post-mortem cleanup operations after the object has been finalized.

Key Characteristics:

• No Direct Access: You cannot retrieve the referenced object via get(). It always returns null.
• Used for Cleanup: It is typically used for resource management, such as closing files or releasing memory in native code.
• Works with ReferenceQueue: The object is enqueued in a ReferenceQueue when the JVM determines it is ready for GC.

How PhantomReference Differs from Other References

Java provides four types of references:

• Strong Reference: The default type; prevents garbage collection.
• Weak Reference: Allows an object to be garbage collected if no strong references exist.
• Soft Reference: Used for memory-sensitive caches; objects are collected only when memory is low.
• Phantom Reference: Unlike other references, it does not prevent garbage collection at all. Instead, it is used to run cleanup actions after an object has been collected, often in conjunction with a ReferenceQueue.

Implementing PhantomReference in Java

To use PhantomReference in Java, we must associate it with a ReferenceQueue, which holds references to objects that have been marked for garbage collection.

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;

public class PhantomReferenceExample {
    public static void main(String[] args) throws InterruptedException {
        ReferenceQueue<Resource> queue = new ReferenceQueue<>();
        Resource resource = new Resource();
        PhantomReference<Resource> phantomRef = new PhantomReference<>(resource, queue);

        // Remove strong reference
        resource = null;
        System.gc(); // Suggest GC
       
        // Wait for the reference to be enqueued
        while (queue.poll() == null) {
            System.gc();
            Thread.sleep(100);
        }
        
        System.out.println("PhantomReference enqueued, performing cleanup...");
    }
}

class Resource {
    void cleanup() {
        System.out.println("Cleaning up resources...");
    }
}

Here,

1. We create a ReferenceQueue to hold PhantomReference objects after GC determines they are unreachable.
2. A PhantomReference to a Resource object is created and linked to the queue.
3. The strong reference to the Resource object is removed (resource = null), allowing it to be garbage collected.
4. The garbage collector runs (System.gc()), and after a delay (Thread.sleep(1000)), we check the ReferenceQueue.
5. If the PhantomReference is enqueued, we perform cleanup operations before removing the reference completely.

Why Use PhantomReference?

The main reason for using PhantomReference in Java is to gain better control over memory cleanup beyond what the garbage collector offers. Some use cases include:

1. Monitoring Garbage Collection: Detect when an object is about to be collected.
2. Resource Cleanup: Free up native resources after Java objects are finalized.
3. Avoiding finalize() Method: finalize() is discouraged due to its unpredictable execution; PhantomReference provides a better alternative.

Conclusion

PhantomReference in Java is a powerful tool for managing memory efficiently. While it may not be needed in everyday development, understanding how it works helps in writing better memory-aware applications. By combining PhantomReference with a ReferenceQueue, you can ensure timely resource cleanup and improve your application’s performance.

If you’re working with large objects, native resources, or need to track garbage collection behavior, PhantomReference in Java provides a robust and flexible solution.