String vs StringBuilder

16.1.1 Why Strings Matter

In Java, String is one of the most used data types, no matter what you build:

• You store user input, email addresses, passwords.

• You send and receive JSON, which is basically all text.

• You create dynamic HTML, logs, URLs, queries — all string manipulation.

Unlike primitive types, String is an object — it lives on the heap and comes with powerful built-in methods.
One unique thing about String in Java is that it is immutable — once created, you cannot change it.
Every “change” you make creates a brand new String object in memory.

Example:

java
String s = "Hello";
s = s + " World";  // creates a new String, doesn't modify the old one

Even though it looks like you “changed” s, Java secretly creates a new string in the background and makes s point to it.

Why is immutability so important?

• Multiple parts of your program can safely share the same string without worrying about someone else modifying it.

• Strings are thread-safe by default — no accidental overwrites.

• It prevents bugs caused by unintended side effects.

BUT:
This immutability comes at a cost — performance issues if you do lots of small edits.
Why? Because you keep creating new objects that the JVM must allocate and garbage collect.

16.1.2 When Should You Use StringBuilder?

When you need to build, append, or modify large or complex strings many times, using plain String is inefficient.

StringBuilder is designed to solve this:

• It is mutable, meaning the internal character array can change.

• It keeps all edits inside the same object — no new object each time.

• It’s perfect for loops, file generation, JSON/XML builders, dynamic queries, and anywhere you keep adding to the same text.

Real world:

• Creating an email template from 50 small pieces → StringBuilder.

• Generating CSV/TSV rows → StringBuilder.

• Logging lots of messages in loops → StringBuilder.

✅ Pro Tip:
Use StringBuilder when:

• You have many string edits inside a loop.

• You need best performance for massive text processing.

• The temporary string doesn’t need to be thread-safe — StringBuilder is not synchronized (faster).

If you need thread safety, use StringBuffer — same API, but synchronized.
However, StringBuffer is rare these days — StringBuilder is the modern go-to.

16.1.3 Mini Lab: Comparing Real Performance

Below is an expanded Mini Lab showing how different String and StringBuilder really are when handling repeated appends.

java
public class StringVsStringBuilderMiniLab {
    public static void main(String[] args) {
        long start, end;

        // Using String (slow for repeated concatenation)
        start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i < 10000; i++) {
            s += "a";
        }
        end = System.currentTimeMillis();
        System.out.println("String time: " + (end - start) + " ms");

        // Using StringBuilder (fast)
        start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            sb.append("a");
        }
        end = System.currentTimeMillis();
        System.out.println("StringBuilder time: " + (end - start) + " ms");
    }
}

Key takeaway:

• With String, each loop makes a new object, copies the old characters, adds one — repeat 10,000 times = massive waste.

• StringBuilder works in-place — same buffer, just expands as needed.

In real apps, this difference can make or break API response times, especially when building long responses.