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.