Mutable vs Immutable Strings

You write some code. You take a string like "Hello". You try to change one letter inside it. And the language just refuses. The string does not change. Instead you get a whole new string back. Confusing, right? This happens because of one idea called immutability. Once you understand it, a lot of string behavior suddenly makes sense. So let us go through it slowly.

📚 What Does Immutable Mean?

A string is immutable when you cannot change it after it is created. Immutable just means “cannot be changed”. Once the string exists, its letters are locked.

Now this sounds strange. We change strings all the time, don’t we? We add text. We replace letters. So how can they be locked?

Here is the trick. When you “change” an immutable string, the language does not edit the old one. It makes a brand new string with the change. Then it throws the old one away. Or it keeps the old one if something else is still using it. Either way, the old string stays exactly as it was.

A mutable string is the opposite. Mutable means “can be changed”. You can edit its letters in the same place in memory. You do not make a new one.

🍫 A Real-World Way to Picture It

Think of a chocolate bar that is already wrapped and sealed.

If the bar is immutable, you cannot open it and remove one piece. You want a bar with one piece missing? Then you have to get a fresh new bar and unwrap that one. The old sealed bar stays sealed forever.

If the bar is mutable, you just open it and take a piece. The same bar now has a piece gone. No new bar needed.

So the question for any language is simple. When you change a string, do you get a fresh bar? Or do you edit the same one?

🔍 Which Languages Have Which?

Different languages made different choices. Here is the short version.

Immutable strings (a change makes a new string):

• Java String
• Python str
• JavaScript strings

Mutable strings (you can change them in place):

• C strings, which are really just arrays of characters (char[])
• C++ std::string, which lets you append with += or grow it in place
• Java StringBuilder, a special class made for changing text in place

🧪 See Immutability With Your Own Eyes

Let us prove it. We take a string. We ask for a changed version. Then we check the original. If the original is untouched, the string is immutable.

In the code below we make a string. We build a new uppercase version from it. Then we print both. Watch the first one. It does not change.

#include <stdio.h>
#include <string.h>
#include <ctype.h>

// C strings ARE mutable. We can edit a char array in place.
void demo() {
    char text[] = "hello";   // a char array we can change
    char upper[6];

    // build an uppercase copy
    for (int i = 0; i < (int)strlen(text); i++) {
        upper[i] = toupper(text[i]);
    }
    upper[strlen(text)] = '\0';

    // we can also change the original in place, because C allows it
    text[0] = 'J';

    printf("original after edit: %s\n", text);
    printf("upper copy: %s\n", upper);
}

int main() {
    demo();
    return 0;
}

original after edit: Jello
upper copy: HELLO

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

// std::string in C++ is mutable, but we show the immutable-style idea:
// make a new uppercase string and leave the original alone.
void demo() {
    string text = "hello";
    string upper = text;            // a separate copy

    for (char &c : upper) {
        c = toupper(c);             // change only the copy
    }

    cout << "original: " << text << endl;
    cout << "upper copy: " << upper << endl;
}

int main() {
    demo();
    return 0;
}

original: hello
upper copy: HELLO

public class ImmutableDemo {
    // Java String is immutable. toUpperCase() returns a NEW string.
    static void demo() {
        String text = "hello";
        String upper = text.toUpperCase(); // makes a brand new string

        // text was NOT changed by the call above
        System.out.println("original: " + text);
        System.out.println("upper copy: " + upper);
    }

    public static void main(String[] args) {
        demo();
    }
}

original: hello
upper copy: HELLO

# Python str is immutable. .upper() returns a NEW string.
def demo():
    text = "hello"
    upper = text.upper()   # makes a brand new string

    # text is untouched
    print("original:", text)
    print("upper copy:", upper)

demo()

original: hello
upper copy: HELLO

// JavaScript strings are immutable. toUpperCase() returns a NEW string.
function demo() {
  const text = "hello";
  const upper = text.toUpperCase(); // makes a brand new string

  // text is untouched
  console.log("original:", text);
  console.log("upper copy:", upper);
}

demo();

original: hello
upper copy: HELLO

🤔 Why Would Anyone Make Strings Immutable?

Good question. If you cannot change them, that sounds annoying. But immutability buys you real safety. And here is why.

• Two parts of your program can share the same string. Nobody can secretly change it under the other one. That is safe sharing.
• The string can be used as a key in a map or a set. Keys must stay the same. If a key could change, the map would get lost.
• The language can reuse the same string in memory instead of making copies. This trick is called interning. Interning means storing one copy of a repeated string and pointing everyone to it.

So immutability is mostly about being safe and predictable. You always know a string is what it was when you got it.

🐌 The Hidden Cost: Building Strings in a Loop

Now the bad news. Immutability has one trap. And almost every beginner falls into it.

Say you want to build one big string. You do it by adding small pieces over and over in a loop. Like joining ten thousand words.

The problem is that each + makes a new string. So on every step the language copies everything you have so far. Then it adds the new piece. The string keeps getting longer. So each copy is bigger than the last.

If you add n pieces, the total copying work grows like 1 + 2 + 3 + ... + n. That sum is about n squared. So this loop is O(n^2). For a big n it becomes painfully slow.

✅ The Right Way to Build a Big String

The fix is simple. Do not glue pieces one by one onto an immutable string. Instead, collect the pieces in something mutable. Then join them all at once at the end. That join is O(n).

Each language has its own tool for this:

• Java: use StringBuilder, which is mutable. Then call .toString() at the end.
• Python: collect pieces in a list. Then use "".join(list).
• JavaScript: push pieces into an array. Then use array.join("").
• C++: std::string is mutable, so call reserve() once and append with += in place.
• C: the array is already mutable, so just write into it.

The code below builds the string "item0item1...item4" the fast way. Notice we never do += on an immutable string inside the loop.

#include <stdio.h>

// A C char array is mutable, so we write into one buffer directly.
void buildString() {
    char buffer[100];
    int pos = 0;

    for (int i = 0; i < 5; i++) {
        // append "item" + i straight into the same buffer
        pos += sprintf(buffer + pos, "item%d", i);
    }

    printf("%s\n", buffer);
}

int main() {
    buildString();
    return 0;
}

item0item1item2item3item4

#include <iostream>
#include <string>
using namespace std;

// std::string supports += efficiently in C++, so we append in place.
void buildString() {
    string result;
    result.reserve(100);   // hint the size to avoid regrowth

    for (int i = 0; i < 5; i++) {
        result += "item";
        result += to_string(i);
    }

    cout << result << endl;
}

int main() {
    buildString();
    return 0;
}

item0item1item2item3item4

public class BuildString {
    // StringBuilder is MUTABLE. We append in place, then build once.
    static void buildString() {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < 5; i++) {
            sb.append("item").append(i);  // edits the same buffer
        }

        String result = sb.toString();    // one final string, O(n)
        System.out.println(result);
    }

    public static void main(String[] args) {
        buildString();
    }
}

item0item1item2item3item4

# Collect pieces in a list (mutable), then join once at the end.
def build_string():
    pieces = []                 # a mutable list

    for i in range(5):
        pieces.append("item" + str(i))  # cheap list append

    result = "".join(pieces)    # one join, O(n)
    print(result)

build_string()

item0item1item2item3item4

// Push pieces into an array (mutable), then join once at the end.
function buildString() {
  const pieces = []; // a mutable array

  for (let i = 0; i < 5; i++) {
    pieces.push("item" + i); // cheap array push
  }

  const result = pieces.join(""); // one join, O(n)
  console.log(result);
}

buildString();

item0item1item2item3item4

⏱️ The Complexity, Side by Side

This table shows why the right way wins. n is the total number of characters in the final string.

🧩 What You’ve Learned

• ✅ Immutable means a string cannot be changed after it is created. Any “change” makes a brand new string.
• ✅ Java String, Python str, and JavaScript strings are immutable. C strings (char[]), C++ std::string, and Java StringBuilder are mutable.
• ✅ Immutability gives you safe sharing, valid map keys, and reuse through interning.
• ✅ Building a big string with += in a loop is O(n^2), because each step copies everything so far.
• ✅ The fast O(n) way is StringBuilder in Java, list + join in Python, and array + join in JavaScript.

🚀 What’s Next?

• Introduction to Strings
• String Operations