Java Strings: Immutability, the String Pool and StringBuilder

Strings are the most common interview topic after OOP. Four ideas cover almost every question: immutability, the string pool, == versus equals(), and StringBuilder.

Strings are immutable

A String object never changes after it is created. Methods such as toUpperCase(), replace() and trim() return a new string.

public class Builder {
    public static void main(String[] args) {
        String s = "hello";
        s.toUpperCase();                         // returns a new String; the result is thrown away
        System.out.println(s);                   // hello
        s = s.toUpperCase();
        System.out.println(s);                   // HELLO

        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(',');
        }
        sb.setLength(sb.length() - 1);           // remove the trailing comma
        System.out.println(sb);                  // 1,2,3,4,5
        System.out.println(new StringBuilder("stressed").reverse());   // desserts
    }
}

Why immutable?

• The string pool needs it. Many variables share one object, so nobody may change it.
• Security: a file path, a URL or a class name cannot be altered after it has been checked.
• Thread safety: immutable objects can be shared freely without locks.
• Cached hash code: a string's hash code is computed once, which makes strings fast and reliable as HashMap keys.

The String Constant Pool

String literals are stored in a special area of the heap called the string pool. Two identical literals refer to the same pooled object. new String("hello") always creates a new object, even though "hello" is already in the pool.

public class StringPool {
    public static void main(String[] args) {
        String a = "hello";
        String b = "hello";
        String c = new String("hello");
        System.out.println(a == b);              // true   (both literals point to the same pooled object)
        System.out.println(a == c);              // false  (new String always creates a new object)
        System.out.println(a.equals(c));         // true
        System.out.println(a == c.intern());     // true   (intern() returns the pooled instance)

        String part = "hel";
        String joined = part + "lo";             // computed at run time: a new object
        System.out.println(a == joined);         // false
        final String constant = "hel";
        System.out.println(a == constant + "lo");   // true   (a constant expression, folded at compile time)
    }
}

• == compares references (are these the same object?). .equals() compares content. Always use .equals() for text.
• intern() returns the pooled instance of a string.
• Concatenating constants is done by the compiler, so the result is pooled. Concatenating with a normal variable happens at run time and creates a new object.

new String("hello") creates up to two objects: the pooled literal (if not already there) and the new heap object. It is almost never the right thing to write.

String, StringBuilder and StringBuffer

Every += on a string inside a loop creates a new string and copies the old characters, so the work grows quadratically. Use a StringBuilder inside loops. A single expression like is fine: the compiler optimizes it.

Methods worth knowing

, and came in Java 11, and text blocks () in Java 15. Also remember , , , , and .

Common mistakes

• Comparing strings with . It sometimes works because of the pool, which makes the bug harder to find.
• Calling or without using the returned string.
• Building a long string with in a loop instead of .
• Calling on a variable that might be . Put the literal first, or use .

Practise

1. Predict each or in , then run it.
2. Reverse a string and check for a palindrome. See the reverse and palindrome snippet.
3. Count the characters in a word with a . See the character frequency snippet.