Amol Pawar

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.