Why Strings Are Immutable in Java

In Java, once a String object is created, its contents can never change. Methods that appear to modify a String, such as concat() or replace(), actually return a brand-new String object and leave the original untouched. This is not an accident or a limitation — it is a deliberate design decision with several concrete benefits.

Why it matters

Immutability is the reason Strings can be shared safely between threads, cached in a pool, and trusted as map keys and as arguments to security-sensitive code. It also explains the behaviour that trips people up: passing a String to a method can never change the caller's String. "Why is String immutable?" is one of the most frequently asked Java interview questions.

Security

Many sensitive operations take a String as a parameter: opening a file path, connecting to a network host, loading a class by name, or checking a username. If String were mutable, code could validate a String (for example, checking that a file path is safe) and then have another part of the program — or malicious code — change the contents of that same String object afterward, bypassing the validation entirely. Immutability guarantees that once a String has been checked, it cannot be altered underneath the code that checked it.

The String Pool and Thread-Safety

Java maintains a special memory area called the String pool (part of the heap) where String literals are cached and reused. When you write String a = "hello"; and String b = "hello";, both variables point to the exact same object in the pool, saving memory. This sharing is only safe because Strings cannot change — if one reference could modify the shared object, every other reference to that literal would unexpectedly change too. Immutability also makes String inherently thread-safe: multiple threads can read the same String concurrently with no risk of one thread seeing a partially modified value, and no synchronization is needed.

Safe Use as HashMap Keys

String's hashCode() is computed once and cached internally, because the value can never change after construction. This makes String an excellent, efficient key type for HashMap and HashSet — the hash code is guaranteed to stay valid for the object's entire lifetime, which would not be true for a mutable key (a mutable key that changes after being inserted into a HashMap can become permanently unreachable in that map).

What Actually Happens with s = s + "x"

When you write s = s + "x";, Java does not modify the memory that s originally pointed to. Instead, it creates a brand-new String object containing the concatenated result and reassigns the reference s to point at that new object. The original String object still exists unchanged in memory (and will eventually be garbage collected if nothing else references it) — only the reference variable was updated to point elsewhere.

Example

public class StringImmutabilityDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = s1;

        s1 = s1 + " world"; // creates a new String object, does not modify the original

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 == s2);
    }
}

hello world
hello
false

Exercise

The method below is supposed to add an exclamation mark to the message, but the program prints Hello. Change the method and the call so that it prints Hello!.

public class AddSuffix {

    static void addSuffix(String s) {
        s = s + "!";
    }

    public static void main(String[] args) {
        String message = "Hello";
        addSuffix(message);
        System.out.println(message);
    }
}

public class AddSuffix {

    static String addSuffix(String s) {
        return s + "!";
    }

    public static void main(String[] args) {
        String message = "Hello";
        message = addSuffix(message);
        System.out.println(message); // Hello!
    }
}

Quick quiz

Interview questions