avatar
Java Internals

Why Is String Immutable in Java?

Sarvar Musazade9 min read—views

String is one of the most frequently used classes in Java.

String name = "Sarvar";
String language = "Java";
String endpoint = "/api/users";

Most Java developers know one rule:

String is immutable.

But the important question isn't what does immutable mean?

The more interesting question is:

Why did Java make String immutable, and what advantages does that give us?

To understand that, let's first see what immutability actually means.

1. What Does Immutable Mean?

An immutable object cannot have its internal state changed after it has been created.

Consider:

String name = "Sarvar";

name = name + " Musazade";

It looks like "Sarvar" was modified.

It wasn't.

A new resulting String is produced, and name is reassigned to reference that result.

The original String remains unchanged.

This gives us an important distinction:

String objects are immutable. String variables are not.

A variable can point to another String, but the existing String's contents cannot be modified.

This is one of the biggest benefits of immutability.

Consider:

String a = "Java";
String b = a;

Both variables can reference the same String object.

If String were mutable, imagine Java allowed something like:

a.changeTo("Python");

Because a and b reference the same object, b could suddenly observe "Python" too.

That would make shared Strings dangerous.

But because String is immutable, once "Java" exists, nobody can change that object's contents.

Therefore multiple parts of an application can safely share the same String object.

This safe sharing leads directly to another important Java feature.

Java applications use Strings everywhere.

Consider:

String a = "Java";
String b = "Java";
String c = "Java";
String d = "Java";

Java can reuse the same interned String rather than requiring every occurrence of the literal to correspond to a separate pooled object.

This is the idea behind the String Pool.

Multiple references can point to the same "Java" String.

Why is this safe?

Because "Java" cannot suddenly become something else.

Imagine pooled Strings were mutable.

If one part of the application could modify the shared "Java" object into "Python", every other reference sharing that object could be affected.

String pooling would become far more dangerous.

Immutability makes sharing interned Strings predictable.

4. Advantage — Stable HashMap Keys

This is one of the most practical advantages.

Consider:

Map<String, User> users = new HashMap<>();

String key = "user:42";

users.put(key, user);

HashMap uses the key's hash information to determine where an entry belongs.

Simplifying the process:

key → hashCode() → hash → bucket

Suppose "user:42" causes the entry to be stored through bucket 5.

Now imagine String were mutable.

Suppose we could change the same object from:

"user:42"

to:

"admin:99"

The contents changed.

Therefore its content-based hashCode() could also change.

A later lookup could now calculate a different bucket.

But the existing HashMap entry was placed according to the previous state of the key.

This is a classic problem with mutable HashMap keys.

String avoids it because its contents cannot change after creation.

So once:

String key = "user:42";

has a particular value, that String object's equality/hash-related state stays stable.

5. Advantage #4 — Easier Thread Sharing

Suppose two threads use the same String:

String language = "Java";

Thread A might read it.

Thread B might read it at the same time.

Because the String object's contents cannot change, neither thread has to worry that the other thread will modify the characters inside that String object.

That makes immutable values naturally easier to share between threads.

If String were mutable, we would have another category of problem:

one thread could be reading the value while another changes it.

With immutable String objects, that particular problem doesn't exist.

However, be careful with the conclusion.

This does not mean:

“Everything involving String is automatically thread-safe.”

For example, a shared field referencing a String could still be reassigned.

The important advantage is:

The String object's internal value itself cannot be mutated.

6. Advantage #5 — Predictable Values

Strings represent extremely important information in Java applications.

For example:

String file = "/documents/report.pdf";
String endpoint = "/api/payments";
String className = "com.example.PaymentService";
String username = "sarvar";

Imagine passing one of these Strings to another method:

processFile(file);

If String were mutable, another piece of code holding the same reference could potentially change the underlying value.

That would make programs much harder to reason about.

Immutability gives us a useful guarantee:

If I have a particular String object, its textual value will not suddenly change.

This predictability matters when Strings represent identifiers, paths, configuration values, URLs, class names and many other pieces of application data.

7. Advantage #6 — hashCode() Can Be Reused Efficiently

There's another interesting consequence.

String's hashCode() depends on its contents.

Because those contents cannot change, once Java has calculated the hash for a String, the result remains valid for that String's lifetime.

Modern String implementations can cache the calculated hash internally.

Consider repeated usage:

String key = "user:42";

map.get(key);
map.get(key);
map.get(key);

HashMap repeatedly needs the String's hash.

If String contents could change, caching that hash would be much more complicated because changing the String could invalidate the cached value.

But an immutable String has stable contents.

That makes caching derived information such as its hash practical.

8. But Immutability Has a Cost

There is no free design decision.

Immutability gives String many advantages, but it also means we cannot efficiently keep modifying the same String object.

Consider:

String result = "";

for (int i = 0; i < 1000; i++) {
result = result + i;
}

The existing String cannot simply grow.

Each concatenation produces another result.

Repeatedly building larger Strings can therefore involve unnecessary allocations and copying.

And that explains why another class exists.

9. Why Does StringBuilder Exist?

StringBuilder solves a different problem.

Instead of repeatedly producing immutable String results:

String result = "";

for (int i = 0; i < 1000; i++) {
result = result + i;
}

we can use:

StringBuilder builder = new StringBuilder();

for (int i = 0; i < 1000; i++) {
builder.append(i);
}

String result = builder.toString();

StringBuilder is mutable.

It maintains a buffer that can grow and change while we're building the text.

When we're finished, we create the final String.

So these classes serve different purposes:

String is excellent for representing stable text values.

StringBuilder is excellent for constructing text through repeated modifications.

10. The String Pool and new String()

Now that we understand why immutability matters, this behavior becomes easier to understand:

String a = "Java";
String b = "Java";
String c = new String("Java");

a and b can reference the same interned String.

But new String("Java") explicitly creates a separate String object.

Therefore:

a == b; // true
a == c; // false

a.equals(c); // true

For reference types, == checks object identity.

String.equals() checks String content.

So What Are the Advantages of String Immutability?

If we put everything together, String immutability gives Java several important properties:

  1. Safe sharing — multiple references can use the same String without one changing it for everyone else.
  2. Safe String pooling — interned Strings can be reused without mutation problems.
  3. Stable HashMap keys — content-based equals() and hashCode() behavior cannot change after insertion.
  4. Easier thread sharing — another thread cannot mutate the String object's characters while you're reading them.
  5. Predictability — a String's textual value cannot unexpectedly change.
  6. Hash caching opportunities — because the contents don't change, a calculated hash remains valid.

These advantages are connected.

The same fundamental guarantee makes all of them possible:

Once a String object exists, its value does not change.

And that's the bigger engineering lesson.

Java didn't make String immutable simply because “immutability is good.”

It is a deliberate design decision that supports sharing, memory efficiency, hashing, concurrency, predictability, and performance optimizations.

There is a trade-off: repeated modification becomes expensive.

And Java answers that problem with another abstraction:

StringBuilder

Follow My Content

If you enjoy content about Java, backend engineering, concurrency, computer architecture, and system design, you can follow my work on:

Comments (0)

0/1000

Loading comments...