String vs StringBuilder in Java

String vs StringBuilder in Java comes down to one idea: a String never changes once it exists, while a StringBuilder is a notepad you can keep editing. Below you'll see why that matters, where StringBuffer fits in, and which one to reach for.

What is a String in Java, and why is it immutable?

A String is a piece of text such as "hello". It is immutable, which means "cannot be changed after it is created". The official Java documentation says strings are constant, so methods that look like they edit a string actually hand back a brand-new one.

public class ImmutableDemo {
    public static void main(String[] args) {
        String name = "java";
        name.toUpperCase();              // result is thrown away
        System.out.println(name);        // still "java"

        String loud = name.toUpperCase(); // keep the new String
        System.out.println(loud);
    }
}

java
JAVA

Line 4 made a new String "JAVA" but we didn't save it, so name stayed the same. That's immutability in action.

What is StringBuilder in Java?

StringBuilder is a class that holds a changeable sequence of characters. Its append, insert, delete and reverse methods edit the same object in place. It starts with room for 16 characters and grows automatically when it needs more.

public class BuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("start");
        sb.append("le");        // startle
        sb.insert(4, "le");     // starlet
        sb.reverse();           // telrats
        sb.delete(0, 3);        // rats

        String result = sb.toString();
        System.out.println(result);
    }
}

rats

Line by line:

• new StringBuilder("start") creates a builder holding "start".
• append("le") adds text to the end.
• insert(4, "le") puts text at position 4.
• reverse() flips the characters around.
• delete(0, 3) removes characters from position 0 up to (not including) 3.
• toString() gives you a normal String when you're finished.

Notice that we never wrote sb = sb.append(...). The same object changed each time. You may have seen the same trick with the this keyword, since these methods return this so calls can be chained.

What is the difference between String and StringBuilder?

The big difference is mutability. A String is fixed and every "change" creates a new object. A StringBuilder changes its own contents. That makes StringBuilder the better tool when you add to text many times, and String the better tool for text that stays the same.

Does using + on Strings hurt performance?

For a few joins, no. The + operator is fine and easy to read. The trouble starts inside loops, where each pass can create another temporary String. There, a StringBuilder does the same job with far fewer throwaway objects.

public class LoopDemo {
    public static void main(String[] args) {
        // Fine: a handful of joins
        String greeting = "Hello, " + "Asha" + "!";

        // Better: building text in a loop
        StringBuilder numbers = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            numbers.append(i).append(' ');
        }
        System.out.println(greeting);
        System.out.println(numbers.toString().trim());
    }
}

Hello, Asha!
1 2 3 4 5

Where does StringBuffer fit in?

StringBuffer is the older, thread-safe sibling of StringBuilder. Its methods are synchronized, so several threads can use one instance safely. StringBuilder has the same methods without that locking, so the documentation recommends it unless threads share the object.

How do I compare Strings and StringBuilders?

Use equals to compare String contents. The == operator checks whether two variables point at the same object, which is rarely what you want. StringBuilder does not override equals, so convert to a String first.

public class CompareDemo {
    public static void main(String[] args) {
        String a = new String("hi");
        String b = new String("hi");
        System.out.println(a == b);        // different objects
        System.out.println(a.equals(b));   // same characters

        StringBuilder x = new StringBuilder("hi");
        StringBuilder y = new StringBuilder("hi");
        System.out.println(x.equals(y));                       // object identity only
        System.out.println(x.toString().equals(y.toString())); // compare the text
    }
}

false
true
false
true

When should I use String, StringBuilder or StringBuffer?

Use String for text that stays put. Use StringBuilder when you build or edit text repeatedly, especially in a loop. Use StringBuffer only when one buffer is shared by several threads. Not sure what a class or object is? Start with Java classes and objects.

Quick recap

Where can I read more?

The official reference pages are the best next stop: String, StringBuilder and StringBuffer in the Java SE 21 API documentation.

What's next?

Strings often live inside lists, so try the Java ArrayList tutorial next, or browse the Java keywords list.